Struct SolverScope 

pub struct SolverScope<'t, S: PlanningSolution, D: ScoreDirector<S>> {
    pub inphase_step_count_limit: Option<u64>,
    pub inphase_move_count_limit: Option<u64>,
    pub inphase_score_calc_count_limit: Option<u64>,
    /* private fields */
}

Top-level scope for the entire solving process.

Holds the working solution, score director, and tracks the best solution found.

Type Parameters

• 't - Lifetime of the termination flag reference
• S - The planning solution type
• D - The score director type

Fields

inphase_step_count_limit: Option<u64>

Optional maximum total step count for in-phase termination (T1).

inphase_move_count_limit: Option<u64>

Optional maximum total move count for in-phase termination (T1).

inphase_score_calc_count_limit: Option<u64>

Optional maximum total score calculation count for in-phase termination (T1).

Implementations

impl<'t, S: PlanningSolution, D: ScoreDirector<S>> SolverScope<'t, S, D>

pub fn new(score_director: D) -> Self

Creates a new solver scope with the given score director.

pub fn with_terminate( score_director: D, terminate: Option<&'t AtomicBool>, ) -> Self

Creates a solver scope with a termination flag.

pub fn with_seed(score_director: D, seed: u64) -> Self

Creates a solver scope with a specific random seed.

pub fn with_best_solution_callback( self, callback: Box<dyn Fn(&S) + Send + Sync + 't>, ) -> Self

Sets the best solution callback.

The callback is invoked whenever the best solution improves during solving.

pub fn start_solving(&mut self)

Marks the start of solving.

pub fn elapsed(&self) -> Option<Duration>

Returns the elapsed time since solving started.

pub fn score_director(&self) -> &D

Returns a reference to the score director.

pub fn score_director_mut(&mut self) -> &mut D

Returns a mutable reference to the score director.

pub fn working_solution(&self) -> &S

Returns a reference to the working solution.

pub fn working_solution_mut(&mut self) -> &mut S

Returns a mutable reference to the working solution.

pub fn calculate_score(&mut self) -> S::Score

Calculates and returns the current score.

Also records the score calculation in solver statistics.

pub fn best_solution(&self) -> Option<&S>

Returns the best solution found so far.

pub fn best_score(&self) -> Option<&S::Score>

Returns the best score found so far.

pub fn update_best_solution(&mut self)

Updates the best solution if the current solution is better.

pub fn set_best_solution(&mut self, solution: S, score: S::Score)

Forces an update of the best solution regardless of score comparison.

pub fn rng(&mut self) -> &mut StdRng

Returns a reference to the RNG.

pub fn increment_step_count(&mut self) -> u64

Increments and returns the total step count.

pub fn total_step_count(&self) -> u64

Returns the total step count.

pub fn take_best_solution(self) -> Option<S>

Extracts the best solution, consuming this scope.

pub fn take_best_or_working_solution(self) -> S

Returns the best solution or the current working solution if no best was set.

pub fn take_solution_and_stats(self) -> (S, SolverStats)

Extracts both the solution and stats, consuming this scope.

Returns the best solution (or working solution if none) along with the accumulated solver statistics.

pub fn is_terminate_early(&self) -> bool

Checks if early termination was requested (external flag only).

pub fn set_time_limit(&mut self, limit: Duration)

Sets the time limit for solving.

pub fn set_termination_fn( &mut self, f: Box<dyn Fn(&SolverScope<'t, S, D>) -> bool + Send + Sync + 't>, )

Registers a termination check function that is called inside phase step loops.

This allows Termination trait implementations (e.g., step count, move count, score targets) to fire during a running phase, not only between phases.

The solver sets this before calling phase.solve().

pub fn clear_termination_fn(&mut self)

Clears the registered termination function.

pub fn should_terminate_construction(&self) -> bool

Checks if construction heuristic should terminate.

Construction phases must always complete — they build the initial solution. Step/move/score-calculation count limits are for local search phases only, so this method intentionally excludes those checks.

pub fn should_terminate(&self) -> bool

Checks if solving should terminate (external flag, time limit, OR any registered limits).

pub fn stats(&self) -> &SolverStats

Returns a reference to the solver statistics.

pub fn stats_mut(&mut self) -> &mut SolverStats

Returns a mutable reference to the solver statistics.