Struct SolverHandle 

pub struct SolverHandle<S: PlanningSolution> { /* private fields */ }

Handle for interacting with a running solver.

The solver handle allows submitting problem changes to a solver while it is running. Changes are queued and processed at step boundaries.

Example

use solverforge_solver::realtime::{SolverHandle, ProblemChange, ProblemChangeResult};
use solverforge_scoring::ScoreDirector;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

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

#[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; }
}

#[derive(Debug)]
struct AddTask { id: usize }

impl ProblemChange<Solution> for AddTask {
    fn apply(&self, sd: &mut dyn ScoreDirector<Solution>) {
        sd.working_solution_mut().tasks.push(Task { id: self.id });
        sd.trigger_variable_listeners();
    }
}

// Create a handle (normally obtained from RealtimeSolver)
let (handle, _rx) = SolverHandle::<Solution>::new();

// Submit a change while solver is "running"
handle.set_solving(true);
let result = handle.add_problem_change(AddTask { id: 42 });
assert_eq!(result, ProblemChangeResult::Queued);

// When solver stops, changes are rejected
handle.set_solving(false);
let result = handle.add_problem_change(AddTask { id: 43 });
assert_eq!(result, ProblemChangeResult::SolverNotRunning);

Implementations

impl<S: PlanningSolution> SolverHandle<S>

pub fn new() -> (Self, ProblemChangeReceiver<S>)

Creates a new solver handle and its corresponding receiver.

The receiver should be passed to the solver to receive changes.

pub fn add_problem_change<P: ProblemChange<S> + 'static>( &self, change: P, ) -> ProblemChangeResult

Submits a problem change to the solver.

The change is queued and will be processed at the next step boundary. Returns the result of the submission.

pub fn add_problem_change_boxed( &self, change: BoxedProblemChange<S>, ) -> ProblemChangeResult

Submits a boxed problem change to the solver.

pub fn is_solving(&self) -> bool

Returns true if the solver is currently running.

pub fn terminate_early(&self)

Requests early termination of the solver.

The solver will stop at the next step boundary.

pub fn set_solving(&self, solving: bool)

Sets the solving flag (used internally by the solver).

Trait Implementations

impl<S: PlanningSolution> Clone for SolverHandle<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: PlanningSolution> Debug for SolverHandle<S>

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

Formats the value using the given formatter.