Struct CloneablePhaseFactory 

pub struct CloneablePhaseFactory<P> { /* private fields */ }

A simple phase factory that clones a prototype phase.

This factory stores a prototype phase and clones it for each solve. Use this when your phase type implements Clone.

Example

use solverforge_solver::manager::{CloneablePhaseFactory, 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; }
}

// A simple cloneable phase
#[derive(Clone, Debug)]
struct SimplePhase;

impl Phase<MySolution> for SimplePhase {
    fn solve(&mut self, _scope: &mut SolverScope<MySolution>) {}
    fn phase_type_name(&self) -> &'static str { "SimplePhase" }
}

// Create factory that will clone this phase for each solve
let factory = CloneablePhaseFactory::new(SimplePhase);
let phase = factory.create_phase();
assert_eq!(phase.phase_type_name(), "SimplePhase");

Implementations

impl<P: Clone> CloneablePhaseFactory<P>

pub fn new(prototype: P) -> Self

Creates a new factory from a prototype phase.

The prototype will be cloned each time SolverPhaseFactory::create_phase() is called.

Example

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

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

let factory = CloneablePhaseFactory::new(MyPhase);

Trait Implementations

impl<S, P> SolverPhaseFactory<S> for CloneablePhaseFactory<P>

where S: PlanningSolution, P: Phase<S> + Clone + Send + Sync + 'static,

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

Creates a new phase instance.