Struct std::time::Duration

pub struct Duration { /* fields omitted */ }

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

Each duration is composed of a number of seconds and nanosecond precision. APIs binding a system timeout will typically round up the nanosecond precision if the underlying system does not support that level of precision.

Durations implement many common traits, including Add, Sub, and other ops traits. Currently a duration may only be inspected for its number of seconds and its nanosecond precision.

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

Methods

impl Duration

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

Creates a new Duration from the specified number of seconds and additional nanosecond precision.

If the 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.

fn from_secs(secs: u64) -> Duration

Creates a new Duration from the specified number of seconds.

fn from_millis(millis: u64) -> Duration

Creates a new Duration from the specified number of milliseconds.

fn as_secs(&self) -> u64

Returns the number of whole seconds represented by this duration.

The extra precision represented by this duration is ignored (i.e. extra nanoseconds are not represented in the returned value).

fn subsec_nanos(&self) -> u32

Returns the nanosecond precision represented by this duration.

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

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

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

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

Examples

Basic usage:

#![feature(duration_checked_ops)]

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(std::u64::MAX, 0)), None);

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

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

Checked duration subtraction. Computes self + other, returning None if the result would be negative or if underflow occurred.

Examples

Basic usage:

#![feature(duration_checked_ops)]

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

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

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

Checked duration multiplication. Computes self * other, returning None if underflow or overflow occurred.

Examples

Basic usage:

#![feature(duration_checked_ops)]

use std::time::Duration;

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

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

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

Checked duration division. Computes self / other, returning None if other == 0 or the operation results in underflow or overflow.

Examples

Basic usage:

#![feature(duration_checked_ops)]

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

Trait Implementations

impl Clone for Duration

fn clone(&self) -> Duration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Duration

impl PartialEq for Duration

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

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

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

This method tests for !=.

impl Eq for Duration

impl PartialOrd for Duration

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

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

fn lt(&self, __arg_0: &Duration) -> bool

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

fn le(&self, __arg_0: &Duration) -> bool

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

fn gt(&self, __arg_0: &Duration) -> bool

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

fn ge(&self, __arg_0: &Duration) -> bool

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

impl Ord for Duration

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

This method returns an Ordering between self and other.

impl Debug for Duration

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for Duration

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

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

impl Add for Duration

type Output = Duration

The resulting type after applying the + operator

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

The method for the + operator

impl AddAssign for Duration

fn add_assign(&mut self, rhs: Duration)

The method for the += operator

impl Sub for Duration

type Output = Duration

The resulting type after applying the - operator

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

The method for the - operator

impl SubAssign for Duration

fn sub_assign(&mut self, rhs: Duration)

The method for the -= operator

impl Mul<u32> for Duration

type Output = Duration

The resulting type after applying the * operator

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

The method for the * operator

impl MulAssign<u32> for Duration

fn mul_assign(&mut self, rhs: u32)

The method for the *= operator

impl Div<u32> for Duration

type Output = Duration

The resulting type after applying the / operator

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

The method for the / operator

impl DivAssign<u32> for Duration

fn div_assign(&mut self, rhs: u32)

The method for the /= operator