Struct ListConstructionPhaseBuilder 

pub struct ListConstructionPhaseBuilder<S, E>
where
    S: PlanningSolution,
    E: Copy + Send + Sync + 'static,
{ /* private fields */ }

Builder for creating list construction phases.

This builder creates phases that assign unassigned list elements to entities using a round-robin strategy. Ideal for VRP-style problems where visits need to be distributed across vehicles.

Type Parameters

• S - The planning solution type
• E - The element type (e.g., visit index)

Example

use solverforge_solver::{ListConstructionPhase, ListConstructionPhaseBuilder};
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Clone)]
struct Vehicle { visits: Vec<usize> }

#[derive(Clone)]
struct Plan { vehicles: Vec<Vehicle>, visits: Vec<()>, score: Option<SimpleScore> }

impl PlanningSolution for Plan {
    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 = ListConstructionPhaseBuilder::<Plan, usize>::new(
    |plan| plan.visits.len(),
    |plan| plan.vehicles.iter().flat_map(|v| v.visits.iter().copied()).collect(),
    |plan| plan.vehicles.len(),
    |plan, entity_idx, element| { plan.vehicles[entity_idx].visits.push(element); },
    |idx| idx,
    "visits",
    1,
);

// Create a concrete phase:
let phase: ListConstructionPhase<Plan, usize> = builder.create_phase();

Implementations

impl<S, E> ListConstructionPhaseBuilder<S, E>

where S: PlanningSolution, E: Copy + Send + Sync + 'static,

pub fn new( element_count: fn(&S) -> usize, get_assigned: fn(&S) -> Vec<E>, entity_count: fn(&S) -> usize, assign_element: fn(&mut S, usize, E), index_to_element: fn(usize) -> E, variable_name: &'static str, descriptor_index: usize, ) -> Self

Creates a new list construction phase builder.

pub fn create_phase(&self) -> ListConstructionPhase<S, E>

Creates the list construction phase.

Trait Implementations

impl<S, E, D> PhaseFactory<S, D> for ListConstructionPhaseBuilder<S, E>

where S: PlanningSolution, E: Copy + PartialEq + Eq + Hash + Send + Sync + 'static, D: ScoreDirector<S>,

type Phase = ListConstructionPhase<S, E>

The concrete phase type produced by this factory.

fn create(&self) -> Self::Phase

Creates a new phase instance with concrete type.