Struct ComplementedGroupConstraint 

pub struct ComplementedGroupConstraint<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>
where
    C: UniCollector<A>,
    Sc: Score,
{ /* private fields */ }

Zero-erasure constraint for complemented grouped results.

Groups A entities by key, then iterates over B entities (complement source), using grouped values where they exist and default values otherwise.

The key function for A returns Option<K>, allowing entities to be skipped when they don’t have a valid key (e.g., unassigned shifts).

Type Parameters

• S - Solution type
• A - Entity type being grouped (e.g., Shift)
• B - Complement entity type (e.g., Employee)
• K - Group key type
• EA - Extractor for A entities
• EB - Extractor for B entities
• KA - Key function for A (returns Option<K> to allow skipping)
• KB - Key function for B
• C - Collector type
• D - Default value function
• W - Weight function
• Sc - Score type

Example

use solverforge_scoring::constraint::complemented::ComplementedGroupConstraint;
use solverforge_scoring::stream::collector::count;
use solverforge_scoring::api::constraint_set::IncrementalConstraint;
use solverforge_core::{ConstraintRef, ImpactType};
use solverforge_core::score::SimpleScore;

#[derive(Clone, Hash, PartialEq, Eq)]
struct Employee { id: usize }

#[derive(Clone)]
struct Shift { employee_id: Option<usize> }

#[derive(Clone)]
struct Schedule {
    employees: Vec<Employee>,
    shifts: Vec<Shift>,
}

let constraint = ComplementedGroupConstraint::new(
    ConstraintRef::new("", "Shift count"),
    ImpactType::Penalty,
    |s: &Schedule| s.shifts.as_slice(),
    |s: &Schedule| s.employees.as_slice(),
    |shift: &Shift| shift.employee_id,  // Returns Option<usize>
    |emp: &Employee| emp.id,
    count(),
    |_emp: &Employee| 0usize,
    |count: &usize| SimpleScore::of(*count as i64),
    false,
);

let schedule = Schedule {
    employees: vec![Employee { id: 0 }, Employee { id: 1 }],
    shifts: vec![
        Shift { employee_id: Some(0) },
        Shift { employee_id: Some(0) },
        Shift { employee_id: None },  // Skipped - no key
    ],
};

// Employee 0: 2 shifts, Employee 1: 0 shifts → Total: -2
// Unassigned shift is skipped
assert_eq!(constraint.evaluate(&schedule), SimpleScore::of(-2));

Implementations

impl<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc> ComplementedGroupConstraint<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where S: 'static, A: Clone + 'static, B: Clone + 'static, K: Clone + Eq + Hash, EA: Fn(&S) -> &[A], EB: Fn(&S) -> &[B], KA: Fn(&A) -> Option<K>, KB: Fn(&B) -> K, C: UniCollector<A>, C::Result: Clone, D: Fn(&B) -> C::Result, W: Fn(&C::Result) -> Sc, Sc: Score,

pub fn new( constraint_ref: ConstraintRef, impact_type: ImpactType, extractor_a: EA, extractor_b: EB, key_a: KA, key_b: KB, collector: C, default_fn: D, weight_fn: W, is_hard: bool, ) -> Self

Creates a new complemented group constraint.

Trait Implementations

impl<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc> Debug for ComplementedGroupConstraint<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where C: UniCollector<A>, Sc: Score,

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

Formats the value using the given formatter.

impl<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc> IncrementalConstraint<S, Sc> for ComplementedGroupConstraint<S, A, B, K, EA, EB, KA, KB, C, D, W, Sc>

where S: Send + Sync + 'static, A: Clone + Send + Sync + 'static, B: Clone + Send + Sync + 'static, K: Clone + Eq + Hash + Send + Sync, EA: Fn(&S) -> &[A] + Send + Sync, EB: Fn(&S) -> &[B] + Send + Sync, KA: Fn(&A) -> Option<K> + Send + Sync, KB: Fn(&B) -> K + Send + Sync, C: UniCollector<A> + Send + Sync, C::Accumulator: Send + Sync, C::Result: Clone + Send + Sync, C::Value: Send + Sync, D: Fn(&B) -> C::Result + Send + Sync, W: Fn(&C::Result) -> 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).