Struct SpanParser

struct SpanParser { ... }

A parser for Temporal durations.

Note that in Jiff, a "Temporal duration" is called a "span."

See the fmt::temporal module documentation for more information on the specific format used.

Example

This example shows how to parse a Span from a byte string. (That is, &[u8] and not a &str.)

use jiff::{fmt::temporal::SpanParser, ToSpan};

// A parser can be created in a const context.
static PARSER: SpanParser = SpanParser::new();

let span = PARSER.parse_span(b"P3y7m25dT7h36m")?;
assert_eq!(
    span,
    3.years().months(7).days(25).hours(7).minutes(36).fieldwise(),
);

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

Implementations

impl SpanParser

const fn new() -> SpanParser

Create a new Temporal datetime printer with the default configuration.

fn parse_span<I: AsRef<[u8]>>(self: &Self, input: I) -> Result<Span, Error>

Parse a span string into a Span value.

Errors

This returns an error if the span string given is invalid or if it is valid but doesn't fit in the span range supported by Jiff.

Example

This shows a basic example of using this routine.

use jiff::{fmt::temporal::SpanParser, ToSpan};

static PARSER: SpanParser = SpanParser::new();

let span = PARSER.parse_span(b"PT48m")?;
assert_eq!(span, 48.minutes().fieldwise());

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

Note that unless you need to parse a span from a byte string, at time of writing, there is no other advantage to using this parser directly. It is likely more convenient to just use the FromStr trait implementation on [Span]:

use jiff::{Span, ToSpan};

let span = "PT48m".parse::<Span>()?;
assert_eq!(span, 48.minutes().fieldwise());

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

fn parse_duration<I: AsRef<[u8]>>(self: &Self, input: I) -> Result<SignedDuration, Error>

Parse an ISO 8601 duration string into a [SignedDuration] value.

Errors

This returns an error if the span string given is invalid or if it is valid but can't be converted to a SignedDuration. This can occur when the parsed time exceeds the minimum and maximum SignedDuration values, or if there are any non-zero units greater than hours.

Example

This shows a basic example of using this routine.

use jiff::{fmt::temporal::SpanParser, SignedDuration};

static PARSER: SpanParser = SpanParser::new();

let duration = PARSER.parse_duration(b"PT48m")?;
assert_eq!(duration, SignedDuration::from_mins(48));

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

Note that unless you need to parse a span from a byte string, at time of writing, there is no other advantage to using this parser directly. It is likely more convenient to just use the FromStr trait implementation on [SignedDuration]:

use jiff::SignedDuration;

let duration = "PT48m".parse::<SignedDuration>()?;
assert_eq!(duration, SignedDuration::from_mins(48));

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

impl Debug for SpanParser

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

impl Freeze for SpanParser

impl RefUnwindSafe for SpanParser

impl Send for SpanParser

impl Sync for SpanParser

impl Unpin for SpanParser

impl UnwindSafe for SpanParser

impl<T> Any for SpanParser

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for SpanParser

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

impl<T> BorrowMut for SpanParser

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

impl<T> From for SpanParser

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for SpanParser

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 SpanParser

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

impl<T, U> TryInto for SpanParser

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