Struct IntervalEndpoints 

pub struct IntervalEndpoints {
    pub from: Option<TimePoint>,
    pub to: Option<TimePoint>,
}

A resolved time value — either a single point or an interval.

use duckling::{parse, Locale, Lang, Context, Options, DimensionKind,
               DimensionValue, TimeValue, TimePoint, Grain};
use chrono::{NaiveDate, TimeZone, Utc};

let locale = Locale::new(Lang::EN, None);
let context = Context {
    reference_time: Utc.with_ymd_and_hms(2013, 2, 12, 4, 30, 0).unwrap(),
    ..Context::default()
};
let options = Options::default();

// Single time point
let results = parse("tomorrow", &locale, &[DimensionKind::Time], &context, &options);
if let DimensionValue::Time(TimeValue::Single { value: TimePoint::Naive { value, grain }, .. }) = &results[0].value {
    assert_eq!(*value, NaiveDate::from_ymd_opt(2013, 2, 13).unwrap().and_hms_opt(0, 0, 0).unwrap());
    assert_eq!(*grain, Grain::Day);
} else { panic!("expected Naive time point"); }

// Time interval
let results = parse("from 3pm to 5pm", &locale, &[DimensionKind::Time], &context, &options);
if let DimensionValue::Time(TimeValue::Interval { from: Some(f), to: Some(t), .. }) = &results[0].value {
    assert!(matches!(f, TimePoint::Naive { value, grain: Grain::Hour }
        if *value == NaiveDate::from_ymd_opt(2013, 2, 12).unwrap().and_hms_opt(15, 0, 0).unwrap()));
    assert!(matches!(t, TimePoint::Naive { value, grain: Grain::Hour }
        if *value == NaiveDate::from_ymd_opt(2013, 2, 12).unwrap().and_hms_opt(18, 0, 0).unwrap()));
} else { panic!("expected Interval time value"); }

A pair of interval endpoints, used in the values array for intervals.

Fields

from: Option<TimePoint>

The start of the interval, if bounded.

to: Option<TimePoint>

The end of the interval, if bounded.

Trait Implementations

impl Clone for IntervalEndpoints

fn clone(&self) -> IntervalEndpoints

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IntervalEndpoints

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

Formats the value using the given formatter.

impl PartialEq for IntervalEndpoints

fn eq(&self, other: &IntervalEndpoints) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IntervalEndpoints

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IntervalEndpoints