Struct SignedDuration 

pub struct SignedDuration { /* private fields */ }

Available on crate feature cookies only.

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

pub const ZERO: SignedDuration

Equivalent to 0.seconds().

assert_eq!(SignedDuration::ZERO, 0.seconds());

pub const NANOSECOND: SignedDuration

Equivalent to 1.nanoseconds().

assert_eq!(SignedDuration::NANOSECOND, 1.nanoseconds());

pub const MICROSECOND: SignedDuration

Equivalent to 1.microseconds().

assert_eq!(SignedDuration::MICROSECOND, 1.microseconds());

pub const MILLISECOND: SignedDuration

Equivalent to 1.milliseconds().

assert_eq!(SignedDuration::MILLISECOND, 1.milliseconds());

pub const SECOND: SignedDuration

Equivalent to 1.seconds().

assert_eq!(SignedDuration::SECOND, 1.seconds());

pub const MINUTE: SignedDuration

Equivalent to 1.minutes().

assert_eq!(SignedDuration::MINUTE, 1.minutes());

pub const HOUR: SignedDuration

Equivalent to 1.hours().

assert_eq!(SignedDuration::HOUR, 1.hours());

pub const DAY: SignedDuration

Equivalent to 1.days().

assert_eq!(SignedDuration::DAY, 1.days());

pub const WEEK: SignedDuration

Equivalent to 1.weeks().

assert_eq!(SignedDuration::WEEK, 1.weeks());

pub const MIN: SignedDuration

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

pub const MAX: SignedDuration

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

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

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

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

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

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

This may panic if an overflow occurs.

pub const fn weeks(weeks: i64) -> SignedDuration

Create a new SignedDuration with the given number of weeks. Equivalent to SignedDuration::seconds(weeks * 604_800).

assert_eq!(SignedDuration::weeks(1), 604_800.seconds());

Panics

This may panic if an overflow occurs.

pub const fn days(days: i64) -> SignedDuration

Create a new SignedDuration with the given number of days. Equivalent to SignedDuration::seconds(days * 86_400).

assert_eq!(SignedDuration::days(1), 86_400.seconds());

Panics

This may panic if an overflow occurs.

pub const fn hours(hours: i64) -> SignedDuration

Create a new SignedDuration with the given number of hours. Equivalent to SignedDuration::seconds(hours * 3_600).

assert_eq!(SignedDuration::hours(1), 3_600.seconds());

Panics

This may panic if an overflow occurs.

pub const fn minutes(minutes: i64) -> SignedDuration

Create a new SignedDuration with the given number of minutes. Equivalent to SignedDuration::seconds(minutes * 60).

assert_eq!(SignedDuration::minutes(1), 60.seconds());

Panics

This may panic if an overflow occurs.

pub const fn seconds(seconds: i64) -> SignedDuration

Create a new SignedDuration with the given number of seconds.

assert_eq!(SignedDuration::seconds(1), 1_000.milliseconds());

pub const fn seconds_f64(seconds: f64) -> SignedDuration

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

assert_eq!(SignedDuration::seconds_f64(0.5), 0.5.seconds());
assert_eq!(SignedDuration::seconds_f64(-0.5), (-0.5).seconds());

Panics

This may panic if seconds is NaN or overflows the representable range of SignedDuration.

pub const fn seconds_f32(seconds: f32) -> SignedDuration

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

assert_eq!(SignedDuration::seconds_f32(0.5), 0.5.seconds());
assert_eq!(SignedDuration::seconds_f32(-0.5), (-0.5).seconds());

Panics

This may panic if seconds is NaN or overflows the representable range of SignedDuration.

pub const fn saturating_seconds_f64(seconds: f64) -> SignedDuration

Creates a new SignedDuration 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 SignedDuration of 0 seconds.

assert_eq!(SignedDuration::saturating_seconds_f64(0.5), 0.5.seconds());
assert_eq!(
    SignedDuration::saturating_seconds_f64(-0.5),
    (-0.5).seconds()
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::NAN),
    SignedDuration::new(0, 0),
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::NEG_INFINITY),
    SignedDuration::MIN,
);
assert_eq!(
    SignedDuration::saturating_seconds_f64(f64::INFINITY),
    SignedDuration::MAX,
);

pub const fn saturating_seconds_f32(seconds: f32) -> SignedDuration

Creates a new SignedDuration 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 SignedDuration of 0 seconds.

assert_eq!(SignedDuration::saturating_seconds_f32(0.5), 0.5.seconds());
assert_eq!(
    SignedDuration::saturating_seconds_f32(-0.5),
    (-0.5).seconds()
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::NAN),
    SignedDuration::new(0, 0),
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::NEG_INFINITY),
    SignedDuration::MIN,
);
assert_eq!(
    SignedDuration::saturating_seconds_f32(f32::INFINITY),
    SignedDuration::MAX,
);

pub const fn checked_seconds_f64(seconds: f64) -> Option<SignedDuration>

Creates a new SignedDuration from the specified number of seconds represented as f64. Returns None if the SignedDuration can’t be represented.

assert_eq!(
    SignedDuration::checked_seconds_f64(0.5),
    Some(0.5.seconds())
);
assert_eq!(
    SignedDuration::checked_seconds_f64(-0.5),
    Some((-0.5).seconds())
);
assert_eq!(SignedDuration::checked_seconds_f64(f64::NAN), None);
assert_eq!(SignedDuration::checked_seconds_f64(f64::NEG_INFINITY), None);
assert_eq!(SignedDuration::checked_seconds_f64(f64::INFINITY), None);

pub const fn checked_seconds_f32(seconds: f32) -> Option<SignedDuration>

Creates a new SignedDuration from the specified number of seconds represented as f32. Returns None if the SignedDuration can’t be represented.

assert_eq!(
    SignedDuration::checked_seconds_f32(0.5),
    Some(0.5.seconds())
);
assert_eq!(
    SignedDuration::checked_seconds_f32(-0.5),
    Some((-0.5).seconds())
);
assert_eq!(SignedDuration::checked_seconds_f32(f32::NAN), None);
assert_eq!(SignedDuration::checked_seconds_f32(f32::NEG_INFINITY), None);
assert_eq!(SignedDuration::checked_seconds_f32(f32::INFINITY), None);

pub const fn milliseconds(milliseconds: i64) -> SignedDuration

Create a new SignedDuration with the given number of milliseconds.

assert_eq!(SignedDuration::milliseconds(1), 1_000.microseconds());
assert_eq!(SignedDuration::milliseconds(-1), (-1_000).microseconds());

pub const fn microseconds(microseconds: i64) -> SignedDuration

Create a new SignedDuration with the given number of microseconds.

assert_eq!(SignedDuration::microseconds(1), 1_000.nanoseconds());
assert_eq!(SignedDuration::microseconds(-1), (-1_000).nanoseconds());

pub const fn nanoseconds(nanoseconds: i64) -> SignedDuration

Create a new SignedDuration with the given number of nanoseconds.

assert_eq!(SignedDuration::nanoseconds(1), 1.microseconds() / 1_000);
assert_eq!(SignedDuration::nanoseconds(-1), (-1).microseconds() / 1_000);

pub const fn nanoseconds_i128(nanoseconds: i128) -> SignedDuration

Create a new SignedDuration with the given number of nanoseconds.

assert_eq!(
    SignedDuration::nanoseconds_i128(1_234_567_890),
    1.seconds() + 234_567_890.nanoseconds()
);

Panics

This may panic if an overflow occurs. This may happen because the input range cannot be fully mapped to the output.

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 const 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 const 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: SignedDuration) -> Option<SignedDuration>

Computes self + rhs, returning None if an overflow occurred.

assert_eq!(5.seconds().checked_add(5.seconds()), Some(10.seconds()));
assert_eq!(SignedDuration::MAX.checked_add(1.nanoseconds()), None);
assert_eq!((-5).seconds().checked_add(5.seconds()), Some(0.seconds()));

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

Computes self - rhs, returning None if an overflow occurred.

assert_eq!(
    5.seconds().checked_sub(5.seconds()),
    Some(SignedDuration::ZERO)
);
assert_eq!(SignedDuration::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<SignedDuration>

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!(SignedDuration::MAX.checked_mul(2), None);
assert_eq!(SignedDuration::MIN.checked_mul(2), None);

pub const fn checked_div(self, rhs: i32) -> Option<SignedDuration>

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

Computes -self, returning None if the result would overflow.

assert_eq!(5.seconds().checked_neg(), Some((-5).seconds()));
assert_eq!(SignedDuration::MIN.checked_neg(), None);

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

Computes self + rhs, saturating if an overflow occurred.

assert_eq!(5.seconds().saturating_add(5.seconds()), 10.seconds());
assert_eq!(
    SignedDuration::MAX.saturating_add(1.nanoseconds()),
    SignedDuration::MAX
);
assert_eq!(
    SignedDuration::MIN.saturating_add((-1).nanoseconds()),
    SignedDuration::MIN
);
assert_eq!(
    (-5).seconds().saturating_add(5.seconds()),
    SignedDuration::ZERO
);

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

Computes self - rhs, saturating if an overflow occurred.

assert_eq!(
    5.seconds().saturating_sub(5.seconds()),
    SignedDuration::ZERO
);
assert_eq!(
    SignedDuration::MIN.saturating_sub(1.nanoseconds()),
    SignedDuration::MIN
);
assert_eq!(
    SignedDuration::MAX.saturating_sub((-1).nanoseconds()),
    SignedDuration::MAX
);
assert_eq!(5.seconds().saturating_sub(10.seconds()), (-5).seconds());

pub const fn saturating_mul(self, rhs: i32) -> SignedDuration

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), SignedDuration::ZERO);
assert_eq!(SignedDuration::MAX.saturating_mul(2), SignedDuration::MAX);
assert_eq!(SignedDuration::MIN.saturating_mul(2), SignedDuration::MIN);
assert_eq!(SignedDuration::MAX.saturating_mul(-2), SignedDuration::MIN);
assert_eq!(SignedDuration::MIN.saturating_mul(-2), SignedDuration::MAX);

Trait Implementations

impl Add for SignedDuration

fn add(self, rhs: SignedDuration) -> <SignedDuration as Add>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the + operator.

impl Add<Duration> for SignedDuration

fn add( self, std_duration: Duration, ) -> <SignedDuration as Add<Duration>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the + operator.

impl Add<SignedDuration> for Date

fn add(self, duration: SignedDuration) -> <Date as Add<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the + operator.

impl Add<SignedDuration> for OffsetDateTime

fn add( self, duration: SignedDuration, ) -> <OffsetDateTime as Add<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the + operator.

impl Add<SignedDuration> for PlainDateTime

fn add( self, duration: SignedDuration, ) -> <PlainDateTime as Add<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = PlainDateTime

The resulting type after applying the + operator.

impl Add<SignedDuration> for Time

fn add(self, duration: SignedDuration) -> <Time as Add<SignedDuration>>::Output

Add the sub-day time of the SignedDuration 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<SignedDuration> for Timestamp

fn add(self, rhs: SignedDuration) -> <Timestamp as Add<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the + operator.

impl Add<SignedDuration> for UtcDateTime

fn add( self, duration: SignedDuration, ) -> <UtcDateTime as Add<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = UtcDateTime

The resulting type after applying the + operator.

impl AddAssign for SignedDuration

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<Duration> for SignedDuration

fn add_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Date

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for OffsetDateTime

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for PlainDateTime

fn add_assign(&mut self, duration: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for Time

fn add_assign(&mut self, rhs: SignedDuration)

Performs the += operation.

impl AddAssign<SignedDuration> for Timestamp

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl AddAssign<SignedDuration> for UtcDateTime

fn add_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl Clone for SignedDuration

fn clone(&self) -> SignedDuration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SignedDuration

impl Debug for SignedDuration

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

Formats the value using the given formatter.

impl Default for SignedDuration

fn default() -> SignedDuration

Returns the “default value” for a type.

impl Display for SignedDuration

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 = SignedDuration::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<(), Error>

Formats the value using the given formatter.

impl Div for SignedDuration

fn div(self, rhs: SignedDuration) -> <SignedDuration as Div>::Output

Panics

This may panic if rhs == SignedDuration::ZERO.

type Output = f64

The resulting type after applying the / operator.

impl Div<Duration> for SignedDuration

fn div(self, rhs: Duration) -> <SignedDuration as Div<Duration>>::Output

Panics

This may panic if rhs == SignedDuration::ZERO.

type Output = f64

The resulting type after applying the / operator.

impl Div<f32> for SignedDuration

fn div(self, rhs: f32) -> <SignedDuration as Div<f32>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<f64> for SignedDuration

fn div(self, rhs: f64) -> <SignedDuration as Div<f64>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i8> for SignedDuration

fn div(self, rhs: i8) -> <SignedDuration as Div<i8>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i16> for SignedDuration

fn div(self, rhs: i16) -> <SignedDuration as Div<i16>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<i32> for SignedDuration

fn div(self, rhs: i32) -> <SignedDuration as Div<i32>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u8> for SignedDuration

fn div(self, rhs: u8) -> <SignedDuration as Div<u8>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u16> for SignedDuration

fn div(self, rhs: u16) -> <SignedDuration as Div<u16>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl Div<u32> for SignedDuration

fn div(self, rhs: u32) -> <SignedDuration as Div<u32>>::Output

Panics

This may panic if an overflow occurs or if rhs == 0.

type Output = SignedDuration

The resulting type after applying the / operator.

impl DivAssign<f32> for SignedDuration

fn div_assign(&mut self, rhs: f32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<f64> for SignedDuration

fn div_assign(&mut self, rhs: f64)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i8> for SignedDuration

fn div_assign(&mut self, rhs: i8)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i16> for SignedDuration

fn div_assign(&mut self, rhs: i16)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<i32> for SignedDuration

fn div_assign(&mut self, rhs: i32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u8> for SignedDuration

fn div_assign(&mut self, rhs: u8)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u16> for SignedDuration

fn div_assign(&mut self, rhs: u16)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl DivAssign<u32> for SignedDuration

fn div_assign(&mut self, rhs: u32)

Panics

This may panic if an overflow occurs or if rhs == 0.

impl Eq for SignedDuration

impl Hash for SignedDuration

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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<f32> for SignedDuration

fn mul(self, rhs: f32) -> <SignedDuration as Mul<f32>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<f64> for SignedDuration

fn mul(self, rhs: f64) -> <SignedDuration as Mul<f64>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i8> for SignedDuration

fn mul(self, rhs: i8) -> <SignedDuration as Mul<i8>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i16> for SignedDuration

fn mul(self, rhs: i16) -> <SignedDuration as Mul<i16>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<i32> for SignedDuration

fn mul(self, rhs: i32) -> <SignedDuration as Mul<i32>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u8> for SignedDuration

fn mul(self, rhs: u8) -> <SignedDuration as Mul<u8>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u16> for SignedDuration

fn mul(self, rhs: u16) -> <SignedDuration as Mul<u16>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl Mul<u32> for SignedDuration

fn mul(self, rhs: u32) -> <SignedDuration as Mul<u32>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the * operator.

impl MulAssign<f32> for SignedDuration

fn mul_assign(&mut self, rhs: f32)

Panics

This may panic if an overflow occurs.

impl MulAssign<f64> for SignedDuration

fn mul_assign(&mut self, rhs: f64)

Panics

This may panic if an overflow occurs.

impl MulAssign<i8> for SignedDuration

fn mul_assign(&mut self, rhs: i8)

Panics

This may panic if an overflow occurs.

impl MulAssign<i16> for SignedDuration

fn mul_assign(&mut self, rhs: i16)

Panics

This may panic if an overflow occurs.

impl MulAssign<i32> for SignedDuration

fn mul_assign(&mut self, rhs: i32)

Panics

This may panic if an overflow occurs.

impl MulAssign<u8> for SignedDuration

fn mul_assign(&mut self, rhs: u8)

Panics

This may panic if an overflow occurs.

impl MulAssign<u16> for SignedDuration

fn mul_assign(&mut self, rhs: u16)

Panics

This may panic if an overflow occurs.

impl MulAssign<u32> for SignedDuration

fn mul_assign(&mut self, rhs: u32)

Panics

This may panic if an overflow occurs.

impl Neg for SignedDuration

fn neg(self) -> <SignedDuration as Neg>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Ord for SignedDuration

fn cmp(&self, other: &SignedDuration) -> 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,

Restrict a value to a certain interval.

impl PartialEq for SignedDuration

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

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<Duration> for SignedDuration

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for SignedDuration

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Duration> for SignedDuration

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Sub for SignedDuration

fn sub(self, rhs: SignedDuration) -> <SignedDuration as Sub>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Sub<Duration> for SignedDuration

fn sub(self, rhs: Duration) -> <SignedDuration as Sub<Duration>>::Output

Panics

This may panic if an overflow occurs.

type Output = SignedDuration

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Date

fn sub(self, duration: SignedDuration) -> <Date as Sub<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = Date

The resulting type after applying the - operator.

impl Sub<SignedDuration> for OffsetDateTime

fn sub( self, rhs: SignedDuration, ) -> <OffsetDateTime as Sub<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = OffsetDateTime

The resulting type after applying the - operator.

impl Sub<SignedDuration> for PlainDateTime

fn sub( self, duration: SignedDuration, ) -> <PlainDateTime as Sub<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = PlainDateTime

The resulting type after applying the - operator.

impl Sub<SignedDuration> for Time

fn sub(self, duration: SignedDuration) -> <Time as Sub<SignedDuration>>::Output

Subtract the sub-day time of the SignedDuration 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<SignedDuration> for Timestamp

fn sub(self, rhs: SignedDuration) -> <Timestamp as Sub<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = Timestamp

The resulting type after applying the - operator.

impl Sub<SignedDuration> for UtcDateTime

fn sub( self, rhs: SignedDuration, ) -> <UtcDateTime as Sub<SignedDuration>>::Output

Panics

This may panic if an overflow occurs.

type Output = UtcDateTime

The resulting type after applying the - operator.

impl SubAssign for SignedDuration

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<Duration> for SignedDuration

fn sub_assign(&mut self, rhs: Duration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Date

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for OffsetDateTime

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for PlainDateTime

fn sub_assign(&mut self, duration: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for Time

fn sub_assign(&mut self, rhs: SignedDuration)

Performs the -= operation.

impl SubAssign<SignedDuration> for Timestamp

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl SubAssign<SignedDuration> for UtcDateTime

fn sub_assign(&mut self, rhs: SignedDuration)

Panics

This may panic if an overflow occurs.

impl Sum for SignedDuration

fn sum<I>(iter: I) -> SignedDuration

where I: Iterator<Item = SignedDuration>,

Takes an iterator and generates Self from the elements by “summing up” the items.

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

fn sum<I>(iter: I) -> SignedDuration

where I: Iterator<Item = &'a SignedDuration>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TryFrom<Duration> for SignedDuration

type Error = ConversionRange

The type returned in the event of a conversion error.

fn try_from(original: Duration) -> Result<SignedDuration, ConversionRange>

Performs the conversion.