Struct ClosurePhaseFactory 

pub struct ClosurePhaseFactory<S, F>
where
    S: PlanningSolution,
    F: Fn() -> Box<dyn Phase<S>> + Send + Sync,
{ /* private fields */ }

A phase factory using a closure.

This factory uses a closure to create phase instances. This is useful when the phase creation requires complex logic or external dependencies that cannot be easily cloned.

Example

use solverforge_solver::manager::{ClosurePhaseFactory, SolverPhaseFactory};
use solverforge_solver::phase::Phase;
use solverforge_solver::scope::SolverScope;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

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

#[derive(Debug)]
struct DynamicPhase { step_count: u32 }
impl Phase<MySolution> for DynamicPhase {
    fn solve(&mut self, _: &mut SolverScope<MySolution>) {}
    fn phase_type_name(&self) -> &'static str { "DynamicPhase" }
}

// Factory creates fresh instances with reset state
let factory = ClosurePhaseFactory::<MySolution, _>::new(|| {
    Box::new(DynamicPhase { step_count: 0 })
});

let phase = factory.create_phase();
assert_eq!(phase.phase_type_name(), "DynamicPhase");

Implementations

impl<S, F> ClosurePhaseFactory<S, F>

where S: PlanningSolution, F: Fn() -> Box<dyn Phase<S>> + Send + Sync,

pub fn new(factory: F) -> Self

Creates a new factory from a closure.

The closure will be called each time a new phase is needed.

Example

use solverforge_solver::manager::ClosurePhaseFactory;
use solverforge_solver::phase::Phase;
use solverforge_solver::scope::SolverScope;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Debug)]
struct P;
impl Phase<S> for P {
    fn solve(&mut self, _: &mut SolverScope<S>) {}
    fn phase_type_name(&self) -> &'static str { "P" }
}

let factory = ClosurePhaseFactory::<S, _>::new(|| Box::new(P));

Trait Implementations

impl<S, F> SolverPhaseFactory<S> for ClosurePhaseFactory<S, F>

where S: PlanningSolution, F: Fn() -> Box<dyn Phase<S>> + Send + Sync,

fn create_phase(&self) -> Box<dyn Phase<S>>

Creates a new phase instance.