Struct `TimeDifference`

struct TimeDifference { ... }

Options for Time::since and Time::until.

This type provides a way to configure the calculation of spans between two Time values. In particular, both Time::since and Time::until accept anything that implements Into<TimeDifference>. There are a few key trait implementations that make this convenient:

From<Time> for TimeDifference will construct a configuration consisting of just the time. So for example, time1.until(time2) will return the span from time1 to time2.
From<DateTime> for TimeDifference will construct a configuration consisting of just the time from the given datetime. So for example, time.since(datetime) returns the span from datetime.time() to time.
From<(Unit, Time)> is a convenient way to specify the largest units that should be present on the span returned. By default, the largest units are hours. Using this trait implementation is equivalent to TimeDifference::new(time).largest(unit).
From<(Unit, DateTime)> is like the one above, but with the time from the given datetime.

One can also provide a TimeDifference value directly. Doing so is necessary to use the rounding features of calculating a span. For example, setting the smallest unit (defaults to Unit::Nanosecond), the rounding mode (defaults to RoundMode::Trunc) and the rounding increment (defaults to 1). The defaults are selected such that no rounding occurs.

Rounding a span as part of calculating it is provided as a convenience. Callers may choose to round the span as a distinct step via Span::round.

Example

This example shows how to round a span between two datetimes to the nearest half-hour, with ties breaking away from zero.

use jiff::{civil::{Time, TimeDifference}, RoundMode, ToSpan, Unit};

let t1 = "08:14:00.123456789".parse::<Time>()?;
let t2 = "15:00".parse::<Time>()?;
let span = t1.until(
    TimeDifference::new(t2)
        .smallest(Unit::Minute)
        .mode(RoundMode::HalfExpand)
        .increment(30),
)?;
assert_eq!(span, 7.hours().fieldwise());

// One less minute, and because of the HalfExpand mode, the span would
// get rounded down.
let t2 = "14:59".parse::<Time>()?;
let span = t1.until(
    TimeDifference::new(t2)
        .smallest(Unit::Minute)
        .mode(RoundMode::HalfExpand)
        .increment(30),
)?;
assert_eq!(span, 6.hours().minutes(30).fieldwise());

# Ok::<(), Box<dyn std::error::Error>>(())

Implementations

`impl TimeDifference`

fn new(time: Time) -> TimeDifference

Create a new default configuration for computing the span between the given time and some other time (specified as the receiver in Time::since or Time::until).

fn smallest(self: Self, unit: Unit) -> TimeDifference

Set the smallest units allowed in the span returned.

Errors

The smallest units must be no greater than the largest units. If this is violated, then computing a span with this configuration will result in an error.

Example

This shows how to round a span between two times to units no less than seconds.

use jiff::{civil::{Time, TimeDifference}, RoundMode, ToSpan, Unit};

let t1 = "08:14:02.5001".parse::<Time>()?;
let t2 = "08:30:03.0001".parse::<Time>()?;
let span = t1.until(
    TimeDifference::new(t2)
        .smallest(Unit::Second)
        .mode(RoundMode::HalfExpand),
)?;
assert_eq!(span, 16.minutes().seconds(1).fieldwise());

# Ok::<(), Box<dyn std::error::Error>>(())

fn largest(self: Self, unit: Unit) -> TimeDifference

Set the largest units allowed in the span returned.

When a largest unit is not specified, computing a span between times behaves as if it were set to Unit::Hour.

Errors

The largest units, when set, must be at least as big as the smallest units (which defaults to Unit::Nanosecond). If this is violated, then computing a span with this configuration will result in an error.

Example

This shows how to round a span between two times to units no bigger than seconds.

use jiff::{civil::{Time, TimeDifference}, ToSpan, Unit};

let t1 = "08:14".parse::<Time>()?;
let t2 = "08:30".parse::<Time>()?;
let span = t1.until(TimeDifference::new(t2).largest(Unit::Second))?;
assert_eq!(span, 960.seconds().fieldwise());

# Ok::<(), Box<dyn std::error::Error>>(())

fn mode(self: Self, mode: RoundMode) -> TimeDifference

Set the rounding mode.

This defaults to RoundMode::Trunc since it's plausible that rounding "up" in the context of computing the span between two times could be surprising in a number of cases. The RoundMode::HalfExpand mode corresponds to typical rounding you might have learned about in school. But a variety of other rounding modes exist.

Example

This shows how to always round "up" towards positive infinity.

use jiff::{civil::{Time, TimeDifference}, RoundMode, ToSpan, Unit};

let t1 = "08:10".parse::<Time>()?;
let t2 = "08:11".parse::<Time>()?;
let span = t1.until(
    TimeDifference::new(t2)
        .smallest(Unit::Hour)
        .mode(RoundMode::Ceil),
)?;
// Only one minute elapsed, but we asked to always round up!
assert_eq!(span, 1.hour().fieldwise());

// Since `Ceil` always rounds toward positive infinity, the behavior
// flips for a negative span.
let span = t1.since(
    TimeDifference::new(t2)
        .smallest(Unit::Hour)
        .mode(RoundMode::Ceil),
)?;
assert_eq!(span, 0.hour().fieldwise());

# Ok::<(), Box<dyn std::error::Error>>(())

fn increment(self: Self, increment: i64) -> TimeDifference

Set the rounding increment for the smallest unit.

The default value is 1. Other values permit rounding the smallest unit to the nearest integer increment specified. For example, if the smallest unit is set to Unit::Minute, then a rounding increment of 30 would result in rounding in increments of a half hour. That is, the only minute value that could result would be 0 or 30.

Errors

The rounding increment must divide evenly into the next highest unit after the smallest unit configured (and must not be equivalent to it). For example, if the smallest unit is Unit::Nanosecond, then some of the valid values for the rounding increment are 1, 2, 4, 5, 100 and 500. Namely, any integer that divides evenly into 1,000 nanoseconds since there are 1,000 nanoseconds in the next highest unit (microseconds).

The error will occur when computing the span, and not when setting the increment here.

Example

This shows how to round the span between two times to the nearest 5 minute increment.

use jiff::{civil::{Time, TimeDifference}, RoundMode, ToSpan, Unit};

let t1 = "08:19".parse::<Time>()?;
let t2 = "12:52".parse::<Time>()?;
let span = t1.until(
    TimeDifference::new(t2)
        .smallest(Unit::Minute)
        .increment(5)
        .mode(RoundMode::HalfExpand),
)?;
assert_eq!(span, 4.hour().minutes(35).fieldwise());

# Ok::<(), Box<dyn std::error::Error>>(())

`impl Clone for TimeDifference`

fn clone(self: &Self) -> TimeDifference

`impl Copy for TimeDifference`

`impl Debug for TimeDifference`

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

`impl Freeze for TimeDifference`

`impl From for TimeDifference`

fn from(dt: DateTime) -> TimeDifference

`impl From for TimeDifference`

fn from((largest, time): (Unit, Time)) -> TimeDifference

`impl From for TimeDifference`

fn from((largest, dt): (Unit, DateTime)) -> TimeDifference

`impl From for TimeDifference`

fn from((largest, zdt): (Unit, Zoned)) -> TimeDifference

`impl From for TimeDifference`

fn from(time: Time) -> TimeDifference

`impl From for TimeDifference`

fn from(zdt: Zoned) -> TimeDifference

`impl RefUnwindSafe for TimeDifference`

`impl Send for TimeDifference`

`impl Sync for TimeDifference`

`impl Unpin for TimeDifference`

`impl UnsafeUnpin for TimeDifference`

`impl UnwindSafe for TimeDifference`

`impl<'a> From for TimeDifference`

fn from((largest, zdt): (Unit, &'a Zoned)) -> TimeDifference

`impl<'a> From for TimeDifference`

fn from(zdt: &'a Zoned) -> TimeDifference

`impl<T> Any for TimeDifference`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for TimeDifference`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for TimeDifference`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for TimeDifference`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for TimeDifference`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for TimeDifference`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for TimeDifference`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for TimeDifference`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for TimeDifference`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>