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

//! Module for the [`True`] helper type.

use std::ops::Not;

use crate::{
	actions::{
		BoolInitActions, BoolInspectionActions, BoolPropagationActions, PropagationActions,
		ReasoningContext,
	},
	constraints::ReasonBuilder,
	model, solver,
};

/// Type that represents compile time constant [`true`] value.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
pub struct True;

impl<Ctx> BoolInitActions<Ctx> for True
where
	bool: BoolInitActions<Ctx>,
{
	fn advise_when_fixed(&self, ctx: &mut Ctx, data: u64) {
		true.advise_when_fixed(ctx, data);
	}

	fn enqueue_when_fixed(&self, ctx: &mut Ctx) {
		true.enqueue_when_fixed(ctx);
	}
}

impl<Ctx> BoolInspectionActions<Ctx> for True {
	fn val(&self, _: &Ctx) -> Option<bool> {
		Some(true)
	}
}

impl<Ctx> BoolPropagationActions<Ctx> for True
where
	Ctx: ReasoningContext + PropagationActions,
{
	fn fix(
		&self,
		ctx: &mut Ctx,
		val: bool,
		reason: impl ReasonBuilder<Ctx>,
	) -> Result<(), <Ctx as ReasoningContext>::Conflict> {
		if !val {
			return Err(ctx.declare_conflict(reason));
		}
		Ok(())
	}
}

impl Not for True {
	type Output = bool;

	fn not(self) -> Self::Output {
		false
	}
}

impl From<True> for model::View<bool> {
	fn from(_: True) -> Self {
		true.into()
	}
}

impl From<True> for solver::View<bool> {
	fn from(_: True) -> Self {
		true.into()
	}
}