Struct SolverFactory 

pub struct SolverFactory<S, D, C, P, T> { /* private fields */ }

Zero-erasure solver factory.

Stores phases as a concrete tuple type P, score calculator as C, and termination as T. No dynamic dispatch anywhere.

Type Parameters

• S - The solution type
• D - The score director type
• C - The score calculator type
• P - The phases tuple type
• T - The termination type

Implementations

impl<S, D, C, P, T> SolverFactory<S, D, C, P, T>

where S: PlanningSolution, D: ScoreDirector<S>, C: Fn(&S) -> S::Score + Send + Sync, P: Phase<S, D>, T: Termination<S, D>,

pub fn new(score_calculator: C, phases: P, termination: T) -> Self

Creates a new SolverFactory with concrete types.

pub fn score_calculator(&self) -> &C

Returns a reference to the score calculator.

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

Calculates score for a solution.

pub fn phases(&self) -> &P

Returns a reference to the phases.

pub fn phases_mut(&mut self) -> &mut P

Returns a mutable reference to the phases.

pub fn termination(&self) -> &T

Returns a reference to the termination.

pub fn solve(&mut self, solver_scope: &mut SolverScope<'_, S, D>)

Solves using the configured phases and termination.

pub fn create_solver(self) -> Solver<'static, P, Option<T>, S, ()>

Creates a Solver from this factory’s configuration.

The returned Solver can be used with solve_with_director() for macro-generated code or solve() for direct use.

impl<S: PlanningSolution> SolverFactory<S, (), (), (), ()>

pub fn builder<D, C>( score_calculator: C, ) -> SolverFactoryBuilder<S, D, C, (), NoTermination>

where C: Fn(&S) -> S::Score + Send + Sync,

Creates a new builder for SolverFactory.

This allows calling SolverFactory::<MySolution>::builder(score_fn) to start building a solver factory.

Example

use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;
use solverforge_solver::manager::solver_factory_builder;

#[derive(Clone)]
struct MySolution {
    score: Option<SimpleScore>,
}

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

let builder = solver_factory_builder::<MySolution, (), _>(|_s| SimpleScore::of(0));