Enum `Designator`

enum Designator

Configuration for SpanPrinter::designator.

This controls which kinds of designators to use when formatting a "friendly" duration. Generally, this only provides one axis of control: the length of each designator.

Example

use jiff::{fmt::friendly::{Designator, SpanPrinter}, ToSpan};

let span = 1.year().months(2);

let printer = SpanPrinter::new();
assert_eq!(printer.span_to_string(&span), "1y 2mo");

let printer = SpanPrinter::new().designator(Designator::Short);
assert_eq!(printer.span_to_string(&span), "1yr 2mos");

let printer = SpanPrinter::new().designator(Designator::Verbose);
assert_eq!(printer.span_to_string(&span), "1year 2months");

let printer = SpanPrinter::new().designator(Designator::HumanTime);
assert_eq!(printer.span_to_string(&span), "1y 2months");

Variants

Verbose

This writes out the full word of each unit designation. For example, year.

Short

This writes out a short but not minimal label for each unit. For example, yr for year and yrs for years.

Compact

This writes out the shortest possible label for each unit that is still generally recognizable. For example, y. Note that in the compact representation, and unlike the verbose and short representations, there is no distinction between singular or plural.

HumanTime

A special mode that uses designator labels that are known to be compatible with the humantime crate.

None of Verbose, Short or Compact are compatible with humantime.

Compact is, on its own, nearly compatible. When using Compact, all designator labels are parsable by humantime except for months and microseconds. For months, Jiff uses mo and mos, but humantime only parses months, month and M. Jiff specifically doesn't support M for months because of the confusability with minutes. For microseconds, Jiff uses µs which humantime does not support parsing.

Most of the designator labels Jiff uses for Short aren't supported by humantime. And even when they are, humantime is inconsistent. For example, humantime supports sec and secs, but only nsec and not nsecs.

Finally, for Verbose, humantime supports spelling out some units in their entirety (e.g., seconds) but not others (e.g., nanoseconds is not supported by humantime).

Therefore, this custom variant is provided so that designator labels that are compatible with both Jiff and humantime, even when there isn't a coherent concept otherwise connecting their style.

Implementations

`impl Clone for Designator`

fn clone(self: &Self) -> Designator

`impl Copy for Designator`

`impl Debug for Designator`

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

`impl Freeze for Designator`

`impl RefUnwindSafe for Designator`

`impl Send for Designator`

`impl Sync for Designator`

`impl Unpin for Designator`

`impl UnsafeUnpin for Designator`

`impl UnwindSafe for Designator`

`impl<T> Any for Designator`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Designator`

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

`impl<T> BorrowMut for Designator`

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

`impl<T> CloneToUninit for Designator`

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

`impl<T> From for Designator`

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

`impl<T> ToOwned for Designator`

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

`impl<T, U> Into for Designator`

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

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

`impl<T, U> TryInto for Designator`

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