Enum `Spacing`

enum Spacing

Configuration for SpanPrinter::spacing.

This controls how much or how little whitespace is inserted into a "friendly" formatted duration. Typically, one wants less whitespace when using short unit designators (i.e., y instead of years), and more whitespace when using longer unit designators.

Example

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

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

// The default tries to balance spacing with compact
// unit designators.
let printer = SpanPrinter::new();
assert_eq!(printer.span_to_string(&span), "1y 2mo");

// But you can use slightly more descriptive
// designators without being too verbose.
let printer = SpanPrinter::new()
    .designator(Designator::Short);
assert_eq!(printer.span_to_string(&span), "1yr 2mos");

// When spacing is removed, it usually looks nicer
// to use compact unit designators.
let printer = SpanPrinter::new()
    .spacing(Spacing::None)
    .designator(Designator::Compact);
assert_eq!(printer.span_to_string(&span), "1y2mo");

// Conversely, when using more spacing, it usually
// looks nicer to use verbose unit designators.
let printer = SpanPrinter::new()
    .spacing(Spacing::BetweenUnitsAndDesignators)
    .designator(Designator::Verbose);
assert_eq!(printer.span_to_string(&span), "1 year 2 months");

Variants

None

Does not insert any ASCII whitespace.

Except in the case that SpanPrinter::hours_minutes_seconds is enabled and one is formatting a span with non-zero calendar units, then an ASCII whitespace is inserted between the calendar and non-calendar units even when Spacing::None is used.

BetweenUnits

Inserts one ASCII whitespace between the unit designator and the next unit value.

For example, 1year 2months.

BetweenUnitsAndDesignators

Inserts one ASCII whitespace between the unit value and the unit designator, in addition to inserting one ASCII whitespace between the unit designator and the next unit value.

For example, 1 year 2 months.

Implementations

`impl Clone for Spacing`

fn clone(self: &Self) -> Spacing

`impl Copy for Spacing`

`impl Debug for Spacing`

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

`impl Freeze for Spacing`

`impl RefUnwindSafe for Spacing`

`impl Send for Spacing`

`impl Sync for Spacing`

`impl Unpin for Spacing`

`impl UnsafeUnpin for Spacing`

`impl UnwindSafe for Spacing`

`impl<T> Any for Spacing`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Spacing`

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

`impl<T> BorrowMut for Spacing`

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

`impl<T> CloneToUninit for Spacing`

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

`impl<T> From for Spacing`

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

`impl<T> ToOwned for Spacing`

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

`impl<T, U> Into for Spacing`

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

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

`impl<T, U> TryInto for Spacing`

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