Struct `SignedDuration`

#[repr(C)]
pub struct SignedDuration { /* private fields */ }

A span of time with nanosecond precision.

Each SignedDuration 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 SignedDuration`

const ZERO: Self = _;

Equivalent to 0.seconds().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::ZERO, 0.seconds());

const NANOSECOND: Self = _;

Equivalent to 1.nanoseconds().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::NANOSECOND, 1.nanoseconds());

const MICROSECOND: Self = _;

Equivalent to 1.microseconds().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::MICROSECOND, 1.microseconds());

const MILLISECOND: Self = _;

Equivalent to 1.milliseconds().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::MILLISECOND, 1.milliseconds());

const SECOND: Self = _;

Equivalent to 1.seconds().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::SECOND, 1.seconds());

const MINUTE: Self = _;

Equivalent to 1.minutes().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::MINUTE, 1.minutes());

const HOUR: Self = _;

Equivalent to 1.hours().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::HOUR, 1.hours());

const DAY: Self = _;

Equivalent to 1.days().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::DAY, 1.days());

const WEEK: Self = _;

Equivalent to 1.weeks().

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::WEEK, 1.weeks());

const MIN: Self = _;

The minimum possible duration. Adding any negative duration to this will cause an overflow.

const MAX: Self = _;

The maximum possible duration. Adding any positive duration to this will cause an overflow.

const fn is_zero(self) -> bool

Check if a duration is exactly zero.

# use time::ext::NumericalDuration;
assert!(0.seconds().is_zero());
assert!(!1.nanoseconds().is_zero());

const fn is_negative(self) -> bool

Check if a duration is negative.

# use time::ext::NumericalDuration;
assert!((-1).seconds().is_negative());
assert!(!0.seconds().is_negative());
assert!(!1.seconds().is_negative());

const fn is_positive(self) -> bool

Check if a duration is positive.

# use time::ext::NumericalDuration;
assert!(1.seconds().is_positive());
assert!(!0.seconds().is_positive());
assert!(!(-1).seconds().is_positive());

const fn abs(self) -> Self

Get the absolute value of the duration.

This method saturates the returned value if it would otherwise overflow.

# use time::ext::NumericalDuration;
assert_eq!(1.seconds().abs(), 1.seconds());
assert_eq!(0.seconds().abs(), 0.seconds());
assert_eq!((-1).seconds().abs(), 1.seconds());

const fn unsigned_abs(self) -> StdDuration

Convert the existing SignedDuration to a std::time::Duration and its sign. This returns a std::time::Duration and does not saturate the returned value (unlike SignedDuration::abs).

# use time::ext::{NumericalDuration, NumericalStdDuration};
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());

const fn new(seconds: i64, nanoseconds: i32) -> Self

Create a new SignedDuration with the provided seconds and nanoseconds. If nanoseconds is at least ±10⁹, it will wrap to the number of seconds.

# use time::{SignedDuration, ext::NumericalDuration};
assert_eq!(SignedDuration::new(1, 0), 1.seconds());
assert_eq!(SignedDuration::new(-1, 0), (-1).seconds());
assert_eq!(SignedDuration::new(1, 2_000_000_000), 3.seconds());

Panics