Struct std::time::Duration

1.3.0 · source ·

pub struct Duration { /* private fields */ }

Expand description

A Duration type to represent a span of time, typically used for system timeouts.

Each Duration is composed of a whole number of seconds and a fractional part represented in nanoseconds. If the underlying system does not support nanosecond-level precision, APIs binding a system timeout will typically round up the number of nanoseconds.

Durations implement many common traits, including Add, Sub, and other ops traits. It implements Default by returning a zero-length Duration.

Examples

use std::time::Duration;
let five_seconds = Duration::new(5, 0);
let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);
assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);
assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);
let ten_millis = Duration::from_millis(10);

Run

Formatting Duration values

Duration intentionally does not have a Display impl, as there are a variety of ways to format spans of time for human readability. Duration provides a Debug impl that shows the full precision of the value.

The Debug output uses the non-ASCII "μs" suffix for microseconds. If your program output may appear in contexts that cannot rely on full Unicode compatibility, you may wish to format Duration objects yourself or use a crate to do so.

Implementations

source

impl Duration

source

pub const SECOND: Duration = Duration::from_secs(1)

🔬 This is a nightly-only experimental API. (duration_constants #57391)

The duration of one second.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::SECOND, Duration::from_secs(1));

Run

source

pub const MILLISECOND: Duration = Duration::from_millis(1)

🔬 This is a nightly-only experimental API. (duration_constants #57391)

The duration of one millisecond.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::MILLISECOND, Duration::from_millis(1));

Run

source

pub const MICROSECOND: Duration = Duration::from_micros(1)

🔬 This is a nightly-only experimental API. (duration_constants #57391)

The duration of one microsecond.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::MICROSECOND, Duration::from_micros(1));

Run

source

pub const NANOSECOND: Duration = Duration::from_nanos(1)

🔬 This is a nightly-only experimental API. (duration_constants #57391)

The duration of one nanosecond.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::NANOSECOND, Duration::from_nanos(1));

Run

1.53.0 · source

pub const ZERO: Duration = Duration::from_nanos(0)

A duration of zero time.

Examples

use std::time::Duration;
let duration = Duration::ZERO;
assert!(duration.is_zero());
assert_eq!(duration.as_nanos(), 0);

Run

1.53.0 · source

pub const MAX: Duration = Duration::new(u64::MAX, NANOS_PER_SEC - 1)

The maximum duration.

May vary by platform as necessary. Must be able to contain the difference between two instances of Instant or two instances of SystemTime. This constraint gives it a value of about 584,942,417,355 years in practice, which is currently used on all platforms.

Examples

use std::time::Duration;
assert_eq!(Duration::MAX, Duration::new(u64::MAX, 1_000_000_000 - 1));

Run

const: 1.58.0 · source

pub const fn new(secs: u64, nanos: u32) -> Duration

Creates a new Duration from the specified number of whole seconds and additional nanoseconds.

If the number of nanoseconds is greater than 1 billion (the number of nanoseconds in a second), then it will carry over into the seconds provided.

Panics

This constructor will panic if the carry from the nanoseconds overflows the seconds counter.

Examples

use std::time::Duration;
let five_seconds = Duration::new(5, 0);

Run

const: 1.32.0 · source

pub const fn from_secs(secs: u64) -> Duration

Creates a new Duration from the specified number of whole seconds.

Examples

use std::time::Duration;
let duration = Duration::from_secs(5);
assert_eq!(5, duration.as_secs());
assert_eq!(0, duration.subsec_nanos());

Run

const: 1.32.0 · source

pub const fn from_millis(millis: u64) -> Duration

Creates a new Duration from the specified number of milliseconds.

Examples

use std::time::Duration;
let duration = Duration::from_millis(2569);
assert_eq!(2, duration.as_secs());
assert_eq!(569_000_000, duration.subsec_nanos());

Run

1.27.0 (const: 1.32.0) · source

pub const fn from_micros(micros: u64) -> Duration

Creates a new Duration from the specified number of microseconds.

Examples

use std::time::Duration;
let duration = Duration::from_micros(1_000_002);
assert_eq!(1, duration.as_secs());
assert_eq!(2000, duration.subsec_nanos());

Run

1.27.0 (const: 1.32.0) · source

pub const fn from_nanos(nanos: u64) -> Duration

Creates a new Duration from the specified number of nanoseconds.

Examples

use std::time::Duration;
let duration = Duration::from_nanos(1_000_000_123);
assert_eq!(1, duration.as_secs());
assert_eq!(123, duration.subsec_nanos());

Run

1.53.0 (const: 1.53.0) · source

pub const fn is_zero(&self) -> bool

Returns true if this Duration spans no time.

Examples

use std::time::Duration;
assert!(Duration::ZERO.is_zero());
assert!(Duration::new(0, 0).is_zero());
assert!(Duration::from_nanos(0).is_zero());
assert!(Duration::from_secs(0).is_zero());
assert!(!Duration::new(1, 1).is_zero());
assert!(!Duration::from_nanos(1).is_zero());
assert!(!Duration::from_secs(1).is_zero());

Run

const: 1.32.0 · source

pub const fn as_secs(&self) -> u64

Returns the number of whole seconds contained by this Duration.

The returned value does not include the fractional (nanosecond) part of the duration, which can be obtained using subsec_nanos.

Examples

use std::time::Duration;
let duration = Duration::new(5, 730023852);
assert_eq!(duration.as_secs(), 5);

Run

To determine the total number of seconds represented by the Duration, use as_secs in combination with subsec_nanos:

use std::time::Duration;
let duration = Duration::new(5, 730023852);
assert_eq!(5.730023852,
 duration.as_secs() as f64
 + duration.subsec_nanos() as f64 * 1e-9);

Run

1.27.0 (const: 1.32.0) · source

pub const fn subsec_millis(&self) -> u32

Returns the fractional part of this Duration, in whole milliseconds.

This method does not return the length of the duration when represented by milliseconds. The returned number always represents a fractional portion of a second (i.e., it is less than one thousand).

Examples

use std::time::Duration;
let duration = Duration::from_millis(5432);
assert_eq!(duration.as_secs(), 5);
assert_eq!(duration.subsec_millis(), 432);

Run

1.27.0 (const: 1.32.0) · source

pub const fn subsec_micros(&self) -> u32

Returns the fractional part of this Duration, in whole microseconds.

This method does not return the length of the duration when represented by microseconds. The returned number always represents a fractional portion of a second (i.e., it is less than one million).

Examples

use std::time::Duration;
let duration = Duration::from_micros(1_234_567);
assert_eq!(duration.as_secs(), 1);
assert_eq!(duration.subsec_micros(), 234_567);

Run

const: 1.32.0 · source

pub const fn subsec_nanos(&self) -> u32

Returns the fractional part of this Duration, in nanoseconds.

This method does not return the length of the duration when represented by nanoseconds. The returned number always represents a fractional portion of a second (i.e., it is less than one billion).

Examples

use std::time::Duration;
let duration = Duration::from_millis(5010);
assert_eq!(duration.as_secs(), 5);
assert_eq!(duration.subsec_nanos(), 10_000_000);

Run

1.33.0 (const: 1.33.0) · source

pub const fn as_millis(&self) -> u128

Returns the total number of whole milliseconds contained by this Duration.

Examples

use std::time::Duration;
let duration = Duration::new(5, 730023852);
assert_eq!(duration.as_millis(), 5730);

Run

1.33.0 (const: 1.33.0) · source

pub const fn as_micros(&self) -> u128

Returns the total number of whole microseconds contained by this Duration.

Examples

use std::time::Duration;
let duration = Duration::new(5, 730023852);
assert_eq!(duration.as_micros(), 5730023);

Run

1.33.0 (const: 1.33.0) · source

pub const fn as_nanos(&self) -> u128

Returns the total number of nanoseconds contained by this Duration.

Examples

use std::time::Duration;
let duration = Duration::new(5, 730023852);
assert_eq!(duration.as_nanos(), 5730023852);

Run

1.16.0 (const: 1.58.0) · source

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

Checked Duration addition. Computes self + other, returning None if overflow occurred.

Examples

Basic usage:

use std::time::Duration;
assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));
assert_eq!(Duration::new(1, 0).checked_add(Duration::new(u64::MAX, 0)), None);

Run

1.53.0 (const: 1.58.0) · source

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

Saturating Duration addition. Computes self + other, returning Duration::MAX if overflow occurred.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::new(0, 0).saturating_add(Duration::new(0, 1)), Duration::new(0, 1));
assert_eq!(Duration::new(1, 0).saturating_add(Duration::new(u64::MAX, 0)), Duration::MAX);

Run

1.16.0 (const: 1.58.0) · source

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

Checked Duration subtraction. Computes self - other, returning None if the result would be negative or if overflow occurred.

Examples

Basic usage:

use std::time::Duration;
assert_eq!(Duration::new(0, 1).checked_sub(Duration::new(0, 0)), Some(Duration::new(0, 1)));
assert_eq!(Duration::new(0, 0).checked_sub(Duration::new(0, 1)), None);

Run

1.53.0 (const: 1.58.0) · source

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

Saturating Duration subtraction. Computes self - other, returning Duration::ZERO if the result would be negative or if overflow occurred.

Examples

use std::time::Duration;
assert_eq!(Duration::new(0, 1).saturating_sub(Duration::new(0, 0)), Duration::new(0, 1));
assert_eq!(Duration::new(0, 0).saturating_sub(Duration::new(0, 1)), Duration::ZERO);

Run

1.16.0 (const: 1.58.0) · source

pub const fn checked_mul(self, rhs: u32) -> Option<Duration>

Checked Duration multiplication. Computes self * other, returning None if overflow occurred.

Examples

Basic usage:

use std::time::Duration;
assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));
assert_eq!(Duration::new(u64::MAX - 1, 0).checked_mul(2), None);

Run

1.53.0 (const: 1.58.0) · source

pub const fn saturating_mul(self, rhs: u32) -> Duration

Saturating Duration multiplication. Computes self * other, returning Duration::MAX if overflow occurred.

Examples

#![feature(duration_constants)]
use std::time::Duration;
assert_eq!(Duration::new(0, 500_000_001).saturating_mul(2), Duration::new(1, 2));
assert_eq!(Duration::new(u64::MAX - 1, 0).saturating_mul(2), Duration::MAX);

Run

1.16.0 (const: 1.58.0) · source

pub const fn checked_div(self, rhs: u32) -> Option<Duration>

Checked Duration division. Computes self / other, returning None if other == 0.

Examples

Basic usage:

use std::time::Duration;
assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
assert_eq!(Duration::new(2, 0).checked_div(0), None);

Run

1.38.0 (const: unstable) · source

pub fn as_secs_f64(&self) -> f64

Returns the number of seconds contained by this Duration as f64.

The returned value does include the fractional (nanosecond) part of the duration.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
assert_eq!(dur.as_secs_f64(), 2.7);

Run

1.38.0 (const: unstable) · source

pub fn as_secs_f32(&self) -> f32

Returns the number of seconds contained by this Duration as f32.

The returned value does include the fractional (nanosecond) part of the duration.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
assert_eq!(dur.as_secs_f32(), 2.7);

Run

1.38.0 (const: unstable) · source

pub fn from_secs_f64(secs: f64) -> Duration

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

Panics

This constructor will panic if secs is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let res = Duration::from_secs_f64(0.0);
assert_eq!(res, Duration::new(0, 0));
let res = Duration::from_secs_f64(1e-20);
assert_eq!(res, Duration::new(0, 0));
let res = Duration::from_secs_f64(4.2e-7);
assert_eq!(res, Duration::new(0, 420));
let res = Duration::from_secs_f64(2.7);
assert_eq!(res, Duration::new(2, 700_000_000));
let res = Duration::from_secs_f64(3e10);
assert_eq!(res, Duration::new(30_000_000_000, 0));
// subnormal float
let res = Duration::from_secs_f64(f64::from_bits(1));
assert_eq!(res, Duration::new(0, 0));
// conversion uses rounding
let res = Duration::from_secs_f64(0.999e-9);
assert_eq!(res, Duration::new(0, 1));

Run

1.38.0 (const: unstable) · source

pub fn from_secs_f32(secs: f32) -> Duration

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

Panics

This constructor will panic if secs is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let res = Duration::from_secs_f32(0.0);
assert_eq!(res, Duration::new(0, 0));
let res = Duration::from_secs_f32(1e-20);
assert_eq!(res, Duration::new(0, 0));
let res = Duration::from_secs_f32(4.2e-7);
assert_eq!(res, Duration::new(0, 420));
let res = Duration::from_secs_f32(2.7);
assert_eq!(res, Duration::new(2, 700_000_048));
let res = Duration::from_secs_f32(3e10);
assert_eq!(res, Duration::new(30_000_001_024, 0));
// subnormal float
let res = Duration::from_secs_f32(f32::from_bits(1));
assert_eq!(res, Duration::new(0, 0));
// conversion uses rounding
let res = Duration::from_secs_f32(0.999e-9);
assert_eq!(res, Duration::new(0, 1));

Run

1.38.0 (const: unstable) · source

pub fn mul_f64(self, rhs: f64) -> Duration

Multiplies Duration by f64.

Panics

This method will panic if result is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));
assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));

Run

1.38.0 (const: unstable) · source

pub fn mul_f32(self, rhs: f32) -> Duration

Multiplies Duration by f32.

Panics

This method will panic if result is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
assert_eq!(dur.mul_f32(3.14), Duration::new(8, 478_000_641));
assert_eq!(dur.mul_f32(3.14e5), Duration::new(847800, 0));

Run

1.38.0 (const: unstable) · source

pub fn div_f64(self, rhs: f64) -> Duration

Divide Duration by f64.

Panics

This method will panic if result is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));
assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_599));

Run

1.38.0 (const: unstable) · source

pub fn div_f32(self, rhs: f32) -> Duration

Divide Duration by f32.

Panics

This method will panic if result is negative, overflows Duration or not finite.

Examples

use std::time::Duration;
let dur = Duration::new(2, 700_000_000);
// note that due to rounding errors result is slightly
// different from 0.859_872_611
assert_eq!(dur.div_f32(3.14), Duration::new(0, 859_872_580));
assert_eq!(dur.div_f32(3.14e5), Duration::new(0, 8_599));

Run

const: unstable · source

pub fn div_duration_f64(self, rhs: Duration) -> f64

🔬 This is a nightly-only experimental API. (div_duration #63139)

Divide Duration by Duration and return f64.

Examples

#![feature(div_duration)]
use std::time::Duration;
let dur1 = Duration::new(2, 700_000_000);
let dur2 = Duration::new(5, 400_000_000);
assert_eq!(dur1.div_duration_f64(dur2), 0.5);

Run

const: unstable · source

pub fn div_duration_f32(self, rhs: Duration) -> f32

🔬 This is a nightly-only experimental API. (div_duration #63139)

Divide Duration by Duration and return f32.

Examples

#![feature(div_duration)]
use std::time::Duration;
let dur1 = Duration::new(2, 700_000_000);
let dur2 = Duration::new(5, 400_000_000);
assert_eq!(dur1.div_duration_f32(dur2), 0.5);

Run

source

impl Duration

source

pub const fn try_from_secs_f32(
secs: f32
) -> Result<Duration, FromFloatSecsError>

🔬 This is a nightly-only experimental API. (duration_checked_float #83400)

The checked version of from_secs_f32.

This constructor will return an Err if secs is negative, overflows Duration or not finite.

Examples

#![feature(duration_checked_float)]
use std::time::Duration;
let res = Duration::try_from_secs_f32(0.0);
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f32(1e-20);
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f32(4.2e-7);
assert_eq!(res, Ok(Duration::new(0, 420)));
let res = Duration::try_from_secs_f32(2.7);
assert_eq!(res, Ok(Duration::new(2, 700_000_048)));
let res = Duration::try_from_secs_f32(3e10);
assert_eq!(res, Ok(Duration::new(30_000_001_024, 0)));
// subnormal float:
let res = Duration::try_from_secs_f32(f32::from_bits(1));
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f32(-5.0);
assert!(res.is_err());
let res = Duration::try_from_secs_f32(f32::NAN);
assert!(res.is_err());
let res = Duration::try_from_secs_f32(2e19);
assert!(res.is_err());
// the conversion uses rounding with tie resolution to even
let res = Duration::try_from_secs_f32(0.999e-9);
assert_eq!(res, Ok(Duration::new(0, 1)));
// this float represents exactly 976562.5e-9
let val = f32::from_bits(0x3A80_0000);
let res = Duration::try_from_secs_f32(val);
assert_eq!(res, Ok(Duration::new(0, 976_562)));
// this float represents exactly 2929687.5e-9
let val = f32::from_bits(0x3B40_0000);
let res = Duration::try_from_secs_f32(val);
assert_eq!(res, Ok(Duration::new(0, 2_929_688)));
// this float represents exactly 1.000_976_562_5
let val = f32::from_bits(0x3F802000);
let res = Duration::try_from_secs_f32(val);
assert_eq!(res, Ok(Duration::new(1, 976_562)));
// this float represents exactly 1.002_929_687_5
let val = f32::from_bits(0x3F806000);
let res = Duration::try_from_secs_f32(val);
assert_eq!(res, Ok(Duration::new(1, 2_929_688)));

Run

source

pub const fn try_from_secs_f64(
secs: f64
) -> Result<Duration, FromFloatSecsError>

🔬 This is a nightly-only experimental API. (duration_checked_float #83400)

The checked version of from_secs_f64.

This constructor will return an Err if secs is negative, overflows Duration or not finite.

Examples

#![feature(duration_checked_float)]
use std::time::Duration;
let res = Duration::try_from_secs_f64(0.0);
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f64(1e-20);
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f64(4.2e-7);
assert_eq!(res, Ok(Duration::new(0, 420)));
let res = Duration::try_from_secs_f64(2.7);
assert_eq!(res, Ok(Duration::new(2, 700_000_000)));
let res = Duration::try_from_secs_f64(3e10);
assert_eq!(res, Ok(Duration::new(30_000_000_000, 0)));
// subnormal float
let res = Duration::try_from_secs_f64(f64::from_bits(1));
assert_eq!(res, Ok(Duration::new(0, 0)));
let res = Duration::try_from_secs_f64(-5.0);
assert!(res.is_err());
let res = Duration::try_from_secs_f64(f64::NAN);
assert!(res.is_err());
let res = Duration::try_from_secs_f64(2e19);
assert!(res.is_err());
// the conversion uses rounding with tie resolution to even
let res = Duration::try_from_secs_f64(0.999e-9);
assert_eq!(res, Ok(Duration::new(0, 1)));
let res = Duration::try_from_secs_f64(0.999_999_999_499);
assert_eq!(res, Ok(Duration::new(0, 999_999_999)));
let res = Duration::try_from_secs_f64(0.999_999_999_501);
assert_eq!(res, Ok(Duration::new(1, 0)));
let res = Duration::try_from_secs_f64(42.999_999_999_499);
assert_eq!(res, Ok(Duration::new(42, 999_999_999)));
let res = Duration::try_from_secs_f64(42.999_999_999_501);
assert_eq!(res, Ok(Duration::new(43, 0)));
// this float represents exactly 976562.5e-9
let val = f64::from_bits(0x3F50_0000_0000_0000);
let res = Duration::try_from_secs_f64(val);
assert_eq!(res, Ok(Duration::new(0, 976_562)));
// this float represents exactly 2929687.5e-9
let val = f64::from_bits(0x3F68_0000_0000_0000);
let res = Duration::try_from_secs_f64(val);
assert_eq!(res, Ok(Duration::new(0, 2_929_688)));
// this float represents exactly 1.000_976_562_5
let val = f64::from_bits(0x3FF0_0400_0000_0000);
let res = Duration::try_from_secs_f64(val);
assert_eq!(res, Ok(Duration::new(1, 976_562)));
// this float represents exactly 1.002_929_687_5
let val = f64::from_bits(0x3_FF00_C000_0000_000);
let res = Duration::try_from_secs_f64(val);
assert_eq!(res, Ok(Duration::new(1, 2_929_688)));

Run

Trait Implementations

source

impl Add<Duration> for Duration

type Output = Duration

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

1.8.0 · source

impl Add<Duration> for Instant

source

fn add(self, other: Duration) -> Instant

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See Instant::checked_add for a version without panic.

type Output = Instant

The resulting type after applying the + operator.

1.8.0 · source

impl Add<Duration> for SystemTime

source

fn add(self, dur: Duration) -> SystemTime

Panics

This function may panic if the resulting point in time cannot be represented by the underlying data structure. See SystemTime::checked_add for a version without panic.

type Output = SystemTime

The resulting type after applying the + operator.

1.9.0 · source

impl AddAssign<Duration> for Duration

source

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more

1.9.0 · source

impl AddAssign<Duration> for Instant

source

fn add_assign(&mut self, other: Duration)

Performs the += operation. Read more

1.9.0 · source

impl AddAssign<Duration> for SystemTime

source

fn add_assign(&mut self, other: Duration)

Performs the += operation. Read more

source

impl Clone for Duration

source

fn clone(&self) -> Duration

Returns a copy of the value. Read more

1.0.0 · source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

1.27.0 · source

impl Debug for Duration

source

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

Formats the value using the given formatter. Read more

source

impl Default for Duration

source

fn default() -> Duration

Returns the "default value" for a type. Read more

source

impl Div<u32> for Duration

type Output = Duration

The resulting type after applying the / operator.

source

fn div(self, rhs: u32) -> Duration

Performs the / operation. Read more

1.9.0 · source

impl DivAssign<u32> for Duration

source

fn div_assign(&mut self, rhs: u32)

Performs the /= operation. Read more

source

impl Hash for Duration

source

fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,

Feeds this value into the given Hasher. Read more

source

fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

Feeds a slice of this type into the given Hasher. Read more

1.31.0 · source

impl Mul<Duration> for u32

type Output = Duration

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

impl Mul<u32> for Duration

type Output = Duration

The resulting type after applying the * operator.

source

fn mul(self, rhs: u32) -> Duration

Performs the * operation. Read more

1.9.0 · source

impl MulAssign<u32> for Duration

source

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation. Read more

source

impl Ord for Duration

source

fn cmp(&self, other: &Duration) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · source

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

Compares and returns the maximum of two values. Read more

1.21.0 · source

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

Compares and returns the minimum of two values. Read more

1.50.0 · source

fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,

Restrict a value to a certain interval. Read more

source

impl PartialEq<Duration> for Duration

source

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

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

source

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

This method tests for !=.

source

impl PartialOrd<Duration> for Duration

source

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

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

1.0.0 · source

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

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

1.0.0 · source

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

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

1.0.0 · source

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

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

1.0.0 · source

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

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

source

impl Sub<Duration> for Duration

type Output = Duration

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

1.8.0 · source

impl Sub<Duration> for Instant

type Output = Instant

The resulting type after applying the - operator.

source

fn sub(self, other: Duration) -> Instant

Performs the - operation. Read more

1.8.0 · source

impl Sub<Duration> for SystemTime

type Output = SystemTime

The resulting type after applying the - operator.

source

fn sub(self, dur: Duration) -> SystemTime

Performs the - operation. Read more

1.9.0 · source

impl SubAssign<Duration> for Duration

source

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more

1.9.0 · source

impl SubAssign<Duration> for Instant

source

fn sub_assign(&mut self, other: Duration)

Performs the -= operation. Read more

1.9.0 · source

impl SubAssign<Duration> for SystemTime

source

fn sub_assign(&mut self, other: Duration)

Performs the -= operation. Read more

1.16.0 · source

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

source

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

Method which takes an iterator and generates Self from the elements by "summing up" the items. Read more

1.16.0 · source

impl Sum<Duration> for Duration

source

fn sum<I>(iter: I) -> Duration where
I: Iterator<Item = Duration>,

Method which takes an iterator and generates Self from the elements by "summing up" the items. Read more

source

impl Copy for Duration

source

impl Eq for Duration

source

impl StructuralEq for Duration

source

impl StructuralPartialEq for Duration