huub 100.0.0

CP+SAT solver framework built to be reliable, performant, and extensible
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Actions available to [`Propagator`](crate::constraints::Propagator)
//! implementations during
//! [`Propagator::initialize`](crate::constraints::Propagator::initialize).

use crate::{
	actions::{
		ConstructionActions, DecisionActions, ReasoningContext,
		boolean::BoolInspectionActions,
		integer::{IntInspectionActions, IntPropCond},
	},
	solver::{DefaultView, View, branchers::BoxedBrancher, queue::PriorityLevel},
};

/// Actions available to [`Propagator`](crate::constraints::Propagator)
/// implementations in
/// [`ReasoningEngine::InitializationContext`](crate::actions::ReasoningEngine::InitializationContext)
/// for Boolean decision variables.
pub trait BoolInitActions<Context>: BoolInspectionActions<Context> {
	/// Advise the propagator when `self` is assigned, allowing the
	/// propagator to decide whether to enqueue itself.
	///
	/// Different from enqueueing, the propagator is always advised of the
	/// assignment, not just when it is not yet enqueued.
	///
	/// This will call
	/// [`Propagator::advise_of_bool_change`](crate::constraints::Propagator::advise_of_bool_change)
	/// on the propagator.
	fn advise_when_fixed(&self, ctx: &mut Context, data: u64);

	/// Enqueue the propagator when `self` is assigned.
	fn enqueue_when_fixed(&self, ctx: &mut Context);
}

/// Actions that can be performed during the initialization of branchers.
pub trait BrancherInitActions: ConstructionActions + DecisionActions {
	/// Ensure that any relevant decision variable are marked internally as a
	/// decidable variable.
	fn ensure_decidable<T: DefaultView>(&mut self, view: impl Into<View<T>>);

	/// Push a new [`Brancher`](crate::solver::branchers::Brancher) to the end
	/// of the solving branching queue.
	fn push_brancher(&mut self, brancher: BoxedBrancher);
}

/// Actions that can be performed when the propagator is posted.
pub trait InitActions {
	/// Advise a propagator when the solver backtracks.
	///
	/// This will call
	/// [`Propagator::advise_of_backtrack`](crate::constraints::Propagator::advise_of_backtrack)
	/// on the propagator.
	fn advise_on_backtrack(&mut self);

	/// Explicitly set whether the propagator should be enqueued immediately.
	fn enqueue_now(&mut self, enqueue: bool);

	/// Set the priority level at which the propagator will be enqueued.
	fn set_priority(&mut self, priority: PriorityLevel);
}

/// Actions available to [`Propagator`](crate::constraints::Propagator)
/// implementations in
/// [`ReasoningEngine::InitializationContext`](crate::actions::ReasoningEngine::InitializationContext)
/// for integer decision variables.
pub trait IntInitActions<Context>: IntInspectionActions<Context>
where
	Context: ReasoningContext + ?Sized,
{
	/// Advise the propagator when `self` is changed according to the given
	/// propagation condition, allowing the propagator to decide whether to
	/// enqueue itself.
	///
	/// Different from enqueueing, the propagator is always advised of the
	/// integer change, not just when it is not yet enqueued.
	///
	/// This will call
	/// [`Propagator::advise_of_int_change`](crate::constraints::Propagator::advise_of_int_change)
	/// on the propagator.
	fn advise_when(&self, ctx: &mut Context, condition: IntPropCond, data: u64);

	/// Enqueue the propagator when `self` is changed according to the given
	/// propagation condition.
	fn enqueue_when(&self, ctx: &mut Context, condition: IntPropCond);
}