Enum `Direction`

enum Direction

Configuration for SpanPrinter::direction.

This controls how the sign, if at all, is included in the formatted duration.

When using the "hours-minutes-seconds" format, Auto and Suffix are both treated as equivalent to Sign when all calendar units (days and greater) are zero.

Example

use jiff::{fmt::friendly::{Direction, SpanPrinter}, SignedDuration};

let duration = SignedDuration::from_secs(-1);

let printer = SpanPrinter::new();
assert_eq!(printer.duration_to_string(&duration), "1s ago");

let printer = SpanPrinter::new().direction(Direction::Sign);
assert_eq!(printer.duration_to_string(&duration), "-1s");

Variants

Auto

Sets the sign format based on other configuration options.

When SpanPrinter::spacing is set to Spacing::None, then Auto is equivalent to Sign.

When using the "hours-minutes-seconds" format, Auto is equivalent to Sign when all calendar units (days and greater) are zero.

Otherwise, Auto is equivalent to Suffix.

This is the default used by SpanPrinter.

Sign

When set, a sign is only written when the span or duration is negative. And when it is written, it is written as a prefix of the formatted duration.

ForceSign

A sign is always written, with - for negative spans and + for all non-negative spans. The sign is always written as a prefix of the formatted duration.

Suffix

When set, a sign is only written when the span or duration is negative. And when it is written, it is written as a suffix via a trailing ago string.

Implementations

`impl Clone for Direction`

fn clone(self: &Self) -> Direction

`impl Copy for Direction`

`impl Debug for Direction`

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

`impl Freeze for Direction`

`impl RefUnwindSafe for Direction`

`impl Send for Direction`

`impl Sync for Direction`

`impl Unpin for Direction`

`impl UnsafeUnpin for Direction`

`impl UnwindSafe for Direction`

`impl<T> Any for Direction`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Direction`

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

`impl<T> BorrowMut for Direction`

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

`impl<T> CloneToUninit for Direction`

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

`impl<T> From for Direction`

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

`impl<T> ToOwned for Direction`

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

`impl<T, U> Into for Direction`

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 Direction`

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

`impl<T, U> TryInto for Direction`

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