Struct IncrementalQuadConstraint 

pub struct IncrementalQuadConstraint<S, A, K, E, KE, F, W, Sc>
where
    Sc: Score,
{ /* private fields */ }

Zero-erasure incremental quad-constraint for self-joins.

All function types are concrete generics - no Arc, no dyn, fully monomorphized. Uses key-based indexing: entities are grouped by join key for O(k) lookups where k is the number of entities sharing the same key.

Quadruples are ordered as (i, j, k, l) where i < j < k < l to avoid duplicates.

Type Parameters

• S - Solution type
• A - Entity type
• K - Key type for grouping (entities with same key form quadruples)
• E - Extractor function Fn(&S) -> &[A]
• KE - Key extractor function Fn(&A) -> K
• F - Filter function Fn(&A, &A, &A, &A) -> bool
• W - Weight function Fn(&A, &A, &A, &A) -> Sc
• Sc - Score type

Example

use solverforge_scoring::constraint::quad_incremental::IncrementalQuadConstraint;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_core::{ConstraintRef, ImpactType};
use solverforge_core::score::SimpleScore;

#[derive(Clone, Debug, Hash, PartialEq, Eq)]
struct Task { team: u32 }

#[derive(Clone)]
struct Solution { tasks: Vec<Task> }

// Penalize when four tasks are on the same team
let constraint = IncrementalQuadConstraint::new(
    ConstraintRef::new("", "Team clustering"),
    ImpactType::Penalty,
    |s: &Solution| s.tasks.as_slice(),
    |t: &Task| t.team,  // Group by team
    |_a: &Task, _b: &Task, _c: &Task, _d: &Task| true,  // All quads in same group match
    |_a: &Task, _b: &Task, _c: &Task, _d: &Task| SimpleScore::of(1),
    false,
);

let solution = Solution {
    tasks: vec![
        Task { team: 1 },
        Task { team: 1 },
        Task { team: 1 },
        Task { team: 1 },
        Task { team: 2 },
    ],
};

// One quadruple: (0, 1, 2, 3) all on team 1 = -1 penalty
assert_eq!(constraint.evaluate(&solution), SimpleScore::of(-1));

Implementations

impl<S, A, K, E, KE, F, W, Sc> IncrementalQuadConstraint<S, A, K, E, KE, F, W, Sc>

where S: 'static, A: Clone + 'static, K: Eq + Hash + Clone, E: Fn(&S) -> &[A], KE: Fn(&A) -> K, F: Fn(&A, &A, &A, &A) -> bool, W: Fn(&A, &A, &A, &A) -> Sc, Sc: Score,

pub fn new( constraint_ref: ConstraintRef, impact_type: ImpactType, extractor: E, key_extractor: KE, filter: F, weight: W, is_hard: bool, ) -> Self

Creates a new zero-erasure incremental quad-constraint.

Trait Implementations

impl<S, A, K, E, KE, F, W, Sc: Score> Debug for IncrementalQuadConstraint<S, A, K, E, KE, F, W, Sc>

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

Formats the value using the given formatter.

impl<S, A, K, E, KE, F, W, Sc> IncrementalConstraint<S, Sc> for IncrementalQuadConstraint<S, A, K, E, KE, F, W, Sc>

where S: Send + Sync + 'static, A: Clone + Debug + Send + Sync + 'static, K: Eq + Hash + Clone + Send + Sync, E: Fn(&S) -> &[A] + Send + Sync, KE: Fn(&A) -> K + Send + Sync, F: Fn(&A, &A, &A, &A) -> bool + Send + Sync, W: Fn(&A, &A, &A, &A) -> Sc + Send + Sync, Sc: Score,

fn evaluate(&self, solution: &S) -> Sc

Full evaluation of this constraint.

fn match_count(&self, solution: &S) -> usize

Returns the number of matches for this constraint.

fn initialize(&mut self, solution: &S) -> Sc

Initializes internal state by inserting all entities.

fn on_insert(&mut self, solution: &S, entity_index: usize) -> Sc

Called when an entity is inserted or its variable changes.

fn on_retract(&mut self, solution: &S, entity_index: usize) -> Sc

Called when an entity is retracted or before its variable changes.

fn reset(&mut self)

Resets internal state for a new solving session.

fn name(&self) -> &str

Returns the constraint name.

fn is_hard(&self) -> bool

Returns true if this is a hard constraint.

fn constraint_ref(&self) -> ConstraintRef

Returns the constraint reference (package + name).

fn get_matches(&self, solution: &S) -> Vec<DetailedConstraintMatch<Sc>>

Returns detailed matches with entity justifications.

fn weight(&self) -> Sc

Returns the constraint weight (score per match).