Struct ClosureProblemChange 

pub struct ClosureProblemChange<S: PlanningSolution, F>
where
    F: Fn(&mut dyn ScoreDirector<S>) + Send,
{ /* private fields */ }

A problem change implemented as a closure.

This is a convenience wrapper for simple changes that don’t need a dedicated struct.

Example

use solverforge_solver::realtime::ClosureProblemChange;
use solverforge_scoring::ScoreDirector;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Clone, Debug)]
struct Task { id: usize, done: bool }

#[derive(Clone, Debug)]
struct Solution {
    tasks: Vec<Task>,
    score: Option<SimpleScore>,
}

impl PlanningSolution for Solution {
    type Score = SimpleScore;
    fn score(&self) -> Option<Self::Score> { self.score }
    fn set_score(&mut self, score: Option<Self::Score>) { self.score = score; }
}

// Mark task 0 as done
let change = ClosureProblemChange::<Solution, _>::new("mark_task_done", |sd| {
    if let Some(task) = sd.working_solution_mut().tasks.get_mut(0) {
        task.done = true;
    }
    sd.trigger_variable_listeners();
});

Implementations

impl<S, F> ClosureProblemChange<S, F>

where S: PlanningSolution, F: Fn(&mut dyn ScoreDirector<S>) + Send,

pub fn new(name: &'static str, change_fn: F) -> Self

Creates a new closure-based problem change.

Arguments

• name - A descriptive name for debugging
• change_fn - The closure that applies the change

Trait Implementations

impl<S, F> Debug for ClosureProblemChange<S, F>

where S: PlanningSolution, F: Fn(&mut dyn ScoreDirector<S>) + Send,

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

Formats the value using the given formatter.

impl<S, F> ProblemChange<S> for ClosureProblemChange<S, F>

where S: PlanningSolution, F: Fn(&mut dyn ScoreDirector<S>) + Send,

fn apply(&self, score_director: &mut dyn ScoreDirector<S>)

Applies this change to the working solution.