Struct SpanParser

pub struct SpanParser { /* private fields */ }

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(),
);

Implementations

impl SpanParser

pub const fn new() -> SpanParser

Create a new Temporal datetime printer with the default configuration.

pub fn parse_span<I: AsRef<[u8]>>(&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());

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());

pub fn parse_duration<I: AsRef<[u8]>>( &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));

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));

Trait Implementations

impl Debug for SpanParser

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

Formats the value using the given formatter.