Struct product_os_async_executor::format::Parsed

source ·

pub struct Parsed { /* private fields */ }

Expand description

A type to hold parsed fields of date and time that can check all fields are consistent.

There are three classes of methods:

set_* methods to set fields you have available. They do a basic range check, and if the same field is set more than once it is checked for consistency.
to_* methods try to make a concrete date and time value out of set fields. They fully check that all fields are consistent and whether the date/datetime exists.
Methods to inspect the parsed fields.

Parsed is used internally by all parsing functions in chrono. It is a public type so that it can be used to write custom parsers that reuse the resolving algorithm, or to inspect the results of a string parsed with chrono without converting it to concrete types.

§Resolving algorithm

Resolving date/time parts is littered with lots of corner cases, which is why common date/time parsers do not implement it correctly.

Chrono provides a complete resolution algorithm that checks all fields for consistency via the Parsed type.

As an easy example, consider RFC 2822. The RFC 2822 date and time format has a day of the week part, which should be consistent with the other date parts. But a strptime-based parse would happily accept inconsistent input:

>>> import time
>>> time.strptime('Wed, 31 Dec 2014 04:26:40 +0000',
                  '%a, %d %b %Y %H:%M:%S +0000')
time.struct_time(tm_year=2014, tm_mon=12, tm_mday=31,
                 tm_hour=4, tm_min=26, tm_sec=40,
                 tm_wday=2, tm_yday=365, tm_isdst=-1)
>>> time.strptime('Thu, 31 Dec 2014 04:26:40 +0000',
                  '%a, %d %b %Y %H:%M:%S +0000')
time.struct_time(tm_year=2014, tm_mon=12, tm_mday=31,
                 tm_hour=4, tm_min=26, tm_sec=40,
                 tm_wday=3, tm_yday=365, tm_isdst=-1)

§Example

Let’s see how Parsed correctly detects the second RFC 2822 string from before is inconsistent.

use chrono::format::{ParseErrorKind, Parsed};
use chrono::Weekday;

let mut parsed = Parsed::new();
parsed.set_weekday(Weekday::Wed)?;
parsed.set_day(31)?;
parsed.set_month(12)?;
parsed.set_year(2014)?;
parsed.set_hour(4)?;
parsed.set_minute(26)?;
parsed.set_second(40)?;
parsed.set_offset(0)?;
let dt = parsed.to_datetime()?;
assert_eq!(dt.to_rfc2822(), "Wed, 31 Dec 2014 04:26:40 +0000");

let mut parsed = Parsed::new();
parsed.set_weekday(Weekday::Thu)?; // changed to the wrong day
parsed.set_day(31)?;
parsed.set_month(12)?;
parsed.set_year(2014)?;
parsed.set_hour(4)?;
parsed.set_minute(26)?;
parsed.set_second(40)?;
parsed.set_offset(0)?;
let result = parsed.to_datetime();

assert!(result.is_err());
if let Err(error) = result {
    assert_eq!(error.kind(), ParseErrorKind::Impossible);
}

The same using chrono’s build-in parser for RFC 2822 (the RFC2822 formatting item) and format::parse() showing how to inspect a field on failure.

use chrono::format::{parse, Fixed, Item, Parsed};
use chrono::Weekday;

let rfc_2822 = [Item::Fixed(Fixed::RFC2822)];

let mut parsed = Parsed::new();
parse(&mut parsed, "Wed, 31 Dec 2014 04:26:40 +0000", rfc_2822.iter())?;
let dt = parsed.to_datetime()?;

assert_eq!(dt.to_rfc2822(), "Wed, 31 Dec 2014 04:26:40 +0000");

let mut parsed = Parsed::new();
parse(&mut parsed, "Thu, 31 Dec 2014 04:26:40 +0000", rfc_2822.iter())?;
let result = parsed.to_datetime();

assert!(result.is_err());
if result.is_err() {
    // What is the weekday?
    assert_eq!(parsed.weekday(), Some(Weekday::Thu));
}

Struct product_os_async_executor::format::ParsedCopy item path

§Resolving algorithm

§Example

Implementations§

impl Parsed

pub fn new() -> Parsed

pub fn set_year(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_year_div_100(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_year_mod_100(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_isoyear(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_isoyear_div_100(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_isoyear_mod_100(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_month(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_week_from_sun(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_week_from_mon(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_isoweek(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_weekday(&mut self, value: Weekday) -> Result<(), ParseError>

§Errors

pub fn set_ordinal(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_day(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_ampm(&mut self, value: bool) -> Result<(), ParseError>

§Errors

pub fn set_hour12(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_hour(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_minute(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_second(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_nanosecond(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_timestamp(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn set_offset(&mut self, value: i64) -> Result<(), ParseError>

§Errors

pub fn to_naive_date(&self) -> Result<NaiveDate, ParseError>

§Errors

pub fn to_naive_time(&self) -> Result<NaiveTime, ParseError>

§Errors

pub fn to_naive_datetime_with_offset( &self, offset: i32, ) -> Result<NaiveDateTime, ParseError>

§Errors

pub fn to_fixed_offset(&self) -> Result<FixedOffset, ParseError>

§Errors

pub fn to_datetime(&self) -> Result<DateTime<FixedOffset>, ParseError>

§Errors

pub fn to_datetime_with_timezone<Tz>( &self, tz: &Tz, ) -> Result<DateTime<Tz>, ParseError>where Tz: TimeZone,

§Errors

pub fn year(&self) -> Option<i32>

pub fn year_div_100(&self) -> Option<i32>

pub fn year_mod_100(&self) -> Option<i32>

pub fn isoyear(&self) -> Option<i32>

pub fn isoyear_div_100(&self) -> Option<i32>

pub fn isoyear_mod_100(&self) -> Option<i32>

pub fn month(&self) -> Option<u32>

pub fn week_from_sun(&self) -> Option<u32>

pub fn week_from_mon(&self) -> Option<u32>

pub fn isoweek(&self) -> Option<u32>

pub fn weekday(&self) -> Option<Weekday>

pub fn ordinal(&self) -> Option<u32>

pub fn day(&self) -> Option<u32>

pub fn hour_div_12(&self) -> Option<u32>

pub fn hour_mod_12(&self) -> Option<u32>

pub fn minute(&self) -> Option<u32>

pub fn second(&self) -> Option<u32>

pub fn nanosecond(&self) -> Option<u32>

pub fn timestamp(&self) -> Option<i64>

pub fn offset(&self) -> Option<i32>

Struct product_os_async_executor::format::Parsed

pub fn to_datetime_with_timezone<Tz>( &self, tz: &Tz, ) -> Result<DateTime<Tz>, ParseError>
where Tz: TimeZone,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,