use solverforge_core::score::Score;
use solverforge_core::ConstraintRef;
use super::super::analysis::{ConstraintAnalysis, DetailedConstraintMatch};
use super::weighting::{scale_contribution, scale_contribution_parts};
use crate::constraint::score_sum::checked;
pub trait SingleConstraint {}
pub trait IncrementalConstraint<S, Sc: Score>: SingleConstraint + Send + Sync {
fn evaluate(&self, solution: &S) -> Sc;
fn match_count(&self, solution: &S) -> usize;
fn initialize(&mut self, solution: &S) -> Sc;
fn on_insert(&mut self, solution: &S, entity_index: usize, descriptor_index: usize) -> Sc;
fn on_retract(&mut self, solution: &S, entity_index: usize, descriptor_index: usize) -> Sc;
#[doc(hidden)]
#[inline]
fn on_insert_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
) -> (Sc, bool) {
(
self.on_insert(solution, entity_index, descriptor_index),
false,
)
}
#[doc(hidden)]
#[inline]
fn on_retract_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
) -> (Sc, bool) {
(
self.on_retract(solution, entity_index, descriptor_index),
false,
)
}
fn reset(&mut self);
fn constraint_ref(&self) -> &ConstraintRef;
fn name(&self) -> &str {
&self.constraint_ref().name
}
fn is_hard(&self) -> bool {
false
}
fn get_matches<'a>(&'a self, _solution: &S) -> Vec<DetailedConstraintMatch<'a, Sc>> {
Vec::new()
}
#[inline]
fn evaluate_weighted(&self, solution: &S, multiplier: u32) -> Sc {
scale_contribution(self.evaluate(solution), multiplier)
}
#[inline]
fn initialize_weighted(&mut self, solution: &S, multiplier: u32) -> Sc {
scale_contribution(self.initialize(solution), multiplier)
}
#[inline]
fn on_insert_weighted(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multiplier: u32,
) -> Sc {
checked(self.on_insert_weighted_overflowing(
solution,
entity_index,
descriptor_index,
multiplier,
))
}
#[doc(hidden)]
#[inline]
fn on_insert_weighted_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multiplier: u32,
) -> (Sc, bool) {
scale_contribution_parts(
self.on_insert_overflowing(solution, entity_index, descriptor_index),
multiplier,
)
}
#[inline]
fn on_retract_weighted(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multiplier: u32,
) -> Sc {
checked(self.on_retract_weighted_overflowing(
solution,
entity_index,
descriptor_index,
multiplier,
))
}
#[doc(hidden)]
#[inline]
fn on_retract_weighted_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multiplier: u32,
) -> (Sc, bool) {
scale_contribution_parts(
self.on_retract_overflowing(solution, entity_index, descriptor_index),
multiplier,
)
}
fn get_matches_weighted<'a>(
&'a self,
solution: &S,
multiplier: u32,
) -> Vec<DetailedConstraintMatch<'a, Sc>> {
let mut matches = self.get_matches(solution);
for detailed in &mut matches {
detailed.score = scale_contribution(detailed.score, multiplier);
}
matches
}
}
#[derive(Debug, Clone)]
pub struct ConstraintResult<'a, Sc> {
pub name: &'a str,
pub score: Sc,
pub match_count: usize,
pub is_hard: bool,
pub weight_multiplier: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ConstraintMetadata<'a> {
pub constraint_ref: &'a ConstraintRef,
pub is_hard: bool,
}
impl<'a> ConstraintMetadata<'a> {
pub fn new(constraint_ref: &'a ConstraintRef, is_hard: bool) -> Self {
Self {
constraint_ref,
is_hard,
}
}
pub fn name(&self) -> &str {
&self.constraint_ref.name
}
pub fn full_name(&self) -> String {
self.constraint_ref.full_name()
}
}
pub trait ConstraintSet<S, Sc: Score>: Send + Sync {
fn evaluate_all(&self, solution: &S) -> Sc;
fn constraint_count(&self) -> usize;
fn constraint_metadata(&self) -> Vec<ConstraintMetadata<'_>> {
deduplicate_constraint_metadata(self.constraint_metadata_entries())
}
fn constraint_metadata_entries(&self) -> Vec<ConstraintMetadata<'_>>;
fn evaluate_each<'a>(&'a self, solution: &S) -> Vec<ConstraintResult<'a, Sc>>;
fn evaluate_detailed<'a>(&'a self, solution: &S) -> Vec<ConstraintAnalysis<'a, Sc>>;
fn initialize_all(&mut self, solution: &S) -> Sc;
fn on_insert_all(&mut self, solution: &S, entity_index: usize, descriptor_index: usize) -> Sc;
fn on_retract_all(&mut self, solution: &S, entity_index: usize, descriptor_index: usize) -> Sc;
#[doc(hidden)]
#[inline]
fn on_insert_all_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
) -> (Sc, bool) {
(
self.on_insert_all(solution, entity_index, descriptor_index),
false,
)
}
#[doc(hidden)]
#[inline]
fn on_retract_all_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
) -> (Sc, bool) {
(
self.on_retract_all(solution, entity_index, descriptor_index),
false,
)
}
fn reset_all(&mut self);
fn constraint_weight_refs<'a>(&'a self, refs: &mut Vec<&'a ConstraintRef>);
fn evaluate_all_weighted(&self, solution: &S, multipliers: &[u32]) -> Sc;
fn evaluate_each_weighted<'a>(
&'a self,
solution: &S,
multipliers: &[u32],
) -> Vec<ConstraintResult<'a, Sc>>;
fn evaluate_detailed_weighted<'a>(
&'a self,
solution: &S,
multipliers: &[u32],
) -> Vec<ConstraintAnalysis<'a, Sc>>;
fn initialize_all_weighted(&mut self, solution: &S, multipliers: &[u32]) -> Sc;
fn on_insert_all_weighted(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multipliers: &[u32],
) -> Sc;
fn on_retract_all_weighted(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multipliers: &[u32],
) -> Sc;
#[doc(hidden)]
#[inline]
fn on_insert_all_weighted_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multipliers: &[u32],
) -> (Sc, bool) {
(
self.on_insert_all_weighted(solution, entity_index, descriptor_index, multipliers),
false,
)
}
#[doc(hidden)]
#[inline]
fn on_retract_all_weighted_overflowing(
&mut self,
solution: &S,
entity_index: usize,
descriptor_index: usize,
multipliers: &[u32],
) -> (Sc, bool) {
(
self.on_retract_all_weighted(solution, entity_index, descriptor_index, multipliers),
false,
)
}
}
pub(super) fn push_constraint_metadata<'a>(
metadata: &mut Vec<ConstraintMetadata<'a>>,
candidate: ConstraintMetadata<'a>,
) {
if let Some(existing) = metadata
.iter()
.find(|item| item.constraint_ref == candidate.constraint_ref)
{
assert_eq!(
existing.is_hard,
candidate.is_hard,
"constraint `{}` has conflicting hard/non-hard metadata",
candidate.full_name()
);
return;
}
metadata.push(candidate);
}
pub(super) fn deduplicate_constraint_metadata<'a>(
candidates: Vec<ConstraintMetadata<'a>>,
) -> Vec<ConstraintMetadata<'a>> {
let mut metadata = Vec::new();
for candidate in candidates {
push_constraint_metadata(&mut metadata, candidate);
}
metadata
}