Struct TimeTableOverIntervalIncrementalPropagator 

pub struct TimeTableOverIntervalIncrementalPropagator<Var, const SYNCHRONISE: bool> { /* private fields */ }

Propagator responsible for using time-table reasoning to propagate the Cumulative constraint where a time-table is a structure which stores the mandatory resource usage of the tasks at different time-points - This method creates a resource profile over an interval rather than creating one per time-point (hence the name). Furthermore, the [TimeTableOverIntervalPropagator] has a generic argument which represents the type of variable used for modelling the start variables, this will be an implementation of IntegerVariable.

The difference between the TimeTableOverIntervalIncrementalPropagator and [TimeTableOverIntervalPropagator] is that the TimeTableOverIntervalIncrementalPropagator does not recalculate the time-table from scratch whenever the Propagator::propagate method is called but it utilises the Propagator::notify method to determine when a mandatory part is added and only updates the structure based on these updated mandatory parts.

See Sections 4.2.1, 4.5.2 and 4.6.1-4.6.3 of [1] for more information about time-table reasoning.

[1] A. Schutt, Improving scheduling by learning. University of Melbourne, Department of Computer Science and Software Engineering, 2011.

Implementations

impl<Var, const SYNCHRONISE: bool> TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

where Var: IntegerVariable + 'static,

pub fn new( arg_tasks: &[ArgTask<Var>], capacity: i32, cumulative_options: CumulativePropagatorOptions, constraint_tag: ConstraintTag, ) -> TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

Trait Implementations

impl<Var, const SYNCHRONISE: bool> Clone for TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

where Var: Clone,

fn clone(&self) -> TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Var, const SYNCHRONISE: bool> Debug for TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

where Var: Debug,

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

Formats the value using the given formatter.

impl<Var, const SYNCHRONISE: bool> Propagator for TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

where Var: IntegerVariable + 'static,

fn propagate(&mut self, context: PropagationContext<'_>) -> Result<(), Conflict>

Performs propagation with state (i.e., with being able to mutate internal data structures, as opposed to Propagator::propagate_from_scratch).

fn notify( &mut self, context: NotificationContext<'_>, local_id: LocalId, event: OpaqueDomainEvent, ) -> EnqueueDecision

Returns whether the propagator should be enqueued for propagation when a [DomainEvent] happens to one of the variables the propagator is subscribed to (as registered during creation with [PropagatorConstructor] using [PropagatorConstructorContext::register]).

fn notify_backtrack( &mut self, context: Domains<'_>, local_id: LocalId, event: OpaqueDomainEvent, )

This function is called when the effect of a [DomainEvent] is undone during backtracking of one of the variables the propagator is subscribed to (as registered during creation with [PropagatorConstructor] using [PropagatorConstructorContext::register_backtrack]).

fn synchronise(&mut self, context: NotificationContext<'_>)

Called after backtracking, allowing the propagator to update its internal data structures given the new variable domains.

fn priority(&self) -> Priority

Returns the Priority of the propagator, used for determining the order in which propagators are called.

fn name(&self) -> &str

Return the name of the propagator.

fn propagate_from_scratch( &self, context: PropagationContext<'_>, ) -> Result<(), Conflict>

Performs propagation from scratch (i.e., without relying on updating internal data structures, as opposed to Propagator::propagate).

fn notify_predicate_id_satisfied( &mut self, _context: NotificationContext<'_>, _predicate_id: PredicateId, ) -> EnqueueDecision

Returns whether the propagator should be enqueued for propagation when a Predicate (with corresponding PredicateId) which the propagator is subscribed to (as registered either during using PropagationContext::register_predicate or during creation with [PropagatorConstructor] using [PropagatorConstructorContext::register_predicate]).

fn detect_inconsistency( &self, _domains: Domains<'_>, ) -> Option<PropagatorConflict>

A function which returns Some with a PropagatorConflict when this propagator can detect an inconsistency (and None otherwise).

fn lazy_explanation( &mut self, _code: u64, _context: ExplanationContext<'_>, ) -> LazyExplanation<'_>

Hook which is called when a propagated Predicate should be explained using a lazy reason.

fn log_statistics(&self, _statistic_logger: StatisticLogger)

Logs statistics of the propagator using the provided StatisticLogger.

impl<Var, const SYNCHRONISE: bool> PropagatorConstructor for TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

where Var: IntegerVariable + 'static,

type PropagatorImpl = TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE>

The propagator that is produced by this constructor.

fn add_inference_checkers(&self, checkers: InferenceCheckers<'_>)

Add inference checkers to the solver if applicable.

fn create( self, context: PropagatorConstructorContext<'_>, ) -> <TimeTableOverIntervalIncrementalPropagator<Var, SYNCHRONISE> as PropagatorConstructor>::PropagatorImpl

Create the propagator instance from Self.