Struct Context 

pub struct Context<L = NoLocation> {
    pub holidays: ContextHolidays,
    pub holidays_unknown: ContextHolidays,
    pub locale: L,
    pub approx_bound_interval_size: Option<TimeDelta>,
}

All the context attached to a parsed OpeningHours expression and that can alter its evaluation semantics.

Fields

holidays: ContextHolidays

A calendar use for evaluation of public and private holidays.

holidays_unknown: ContextHolidays

A calendar of holidays where it is unknown whether it applies to current location or not. Typicaly, this can include regional holidays in a countext where only the country is known.

locale: L

Specify locality of the place attached to the expression: from timezone to coordinates.

approx_bound_interval_size: Option<TimeDelta>

As an approximation, consider that any interval bigger that this size is infinite. This can be enabled if you need better performance and you don’t care if a shop is open in more than a year.

Implementations

impl<L> Context<L>

pub fn with_holidays(self, holidays: ContextHolidays) -> Self

Attach a new holidays component to this context.

pub fn with_holidays_unknown(self, holidays_unknown: ContextHolidays) -> Self

Attach a new unknown holidays component to this context.

pub fn with_locale<L2: Localize>(self, locale: L2) -> Context<L2>

Attach a new locale component to this context.

pub fn approx_bound_interval_size(self, max_size: TimeDelta) -> Self

Enables appromiation of long intervals.

impl Context<TzLocation<Tz>>

pub fn from_coords(coords: Coordinates) -> Self

Available on crate features auto-country and auto-timezone only.

Create a context with given coordinates and try to infer a timezone and a local holiday calendar.

use opening_hours::Context;
use opening_hours::localization::{Coordinates, Country, TzLocation};

let coords = Coordinates::new(48.8535, 2.34839).unwrap();

assert_eq!(
    Context::from_coords(coords),
    Context::default()
        .with_holidays(Country::FR.holidays())
        .with_locale(TzLocation::from_coords(coords)),
);

Trait Implementations

impl<L: Clone> Clone for Context<L>

fn clone(&self) -> Context<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: Debug> Debug for Context<L>

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

Formats the value using the given formatter.

impl Default for Context<NoLocation>

fn default() -> Self

Returns the “default value” for a type.

impl<L: Eq> Eq for Context<L>

impl<L: Hash> Hash for Context<L>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L: PartialEq> PartialEq for Context<L>

fn eq(&self, other: &Context<L>) -> 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<L> StructuralPartialEq for Context<L>