Struct timeout::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.

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.

Examples

use std::time::Duration;

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

fn from_secs(secs: u64) -> Duration

Creates a new Duration from the specified number of seconds.

Examples

use std::time::Duration;

let duration = Duration::from_secs(5);

assert_eq!(5, duration.as_secs());
assert_eq!(0, duration.subsec_nanos());

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!(569000000, duration.subsec_nanos());

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

Examples

use std::time::Duration;

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

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

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

Examples

use std::time::Duration;

let duration = Duration::from_millis(5010);
assert_eq!(duration.subsec_nanos(), 10000000);

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

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

Checked Duration subtraction. Computes self - other, returning None if the result would be negative or if underflow 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);

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

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

Trait Implementations

impl Clone for Duration

fn clone(&self) -> Duration

impl SubAssign<Duration> for Duration

fn sub_assign(&mut self, rhs: Duration)

impl Add<Duration> for Duration

type Output = Duration

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

impl Debug for Duration

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

impl Eq for Duration

impl Mul<u32> for Duration

type Output = Duration

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

impl Div<u32> for Duration

type Output = Duration

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

impl Default for Duration

fn default() -> Duration

impl PartialOrd<Duration> for Duration

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

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

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

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

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

impl Hash for Duration

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

impl PartialEq<Duration> for Duration

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

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

impl DivAssign<u32> for Duration

fn div_assign(&mut self, rhs: u32)

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

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

impl Sum<Duration> for Duration

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

impl Sub<Duration> for Duration

type Output = Duration

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

impl Ord for Duration

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

impl AddAssign<Duration> for Duration

fn add_assign(&mut self, rhs: Duration)

impl MulAssign<u32> for Duration

fn mul_assign(&mut self, rhs: u32)

impl Copy for Duration