Struct ListSwapMove 

pub struct ListSwapMove<S, V> { /* private fields */ }

A move that swaps two elements in list variables.

Supports both intra-list swaps (within same entity) and inter-list swaps (between different entities). Uses typed function pointers for zero-erasure.

Type Parameters

• S - The planning solution type
• V - The list element value type

Example

use solverforge_solver::heuristic::r#move::ListSwapMove;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SoftScore;

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

#[derive(Clone, Debug)]
struct Solution { vehicles: Vec<Vehicle>, score: Option<SoftScore> }

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

fn list_len(s: &Solution, entity_idx: usize) -> usize {
    s.vehicles.get(entity_idx).map_or(0, |v| v.visits.len())
}
fn list_get(s: &Solution, entity_idx: usize, pos: usize) -> Option<i32> {
    s.vehicles.get(entity_idx).and_then(|v| v.visits.get(pos).copied())
}
fn list_set(s: &mut Solution, entity_idx: usize, pos: usize, val: i32) {
    if let Some(v) = s.vehicles.get_mut(entity_idx) {
        if let Some(elem) = v.visits.get_mut(pos) { *elem = val; }
    }
}

// Swap elements at positions 1 and 3 in vehicle 0
let m = ListSwapMove::<Solution, i32>::new(
    0, 1, 0, 3,
    list_len, list_get, list_set,
    "visits", 0,
);

Implementations

impl<S, V> ListSwapMove<S, V>

pub fn new( first_entity_index: usize, first_position: usize, second_entity_index: usize, second_position: usize, list_len: fn(&S, usize) -> usize, list_get: fn(&S, usize, usize) -> Option<V>, list_set: fn(&mut S, usize, usize, V), variable_name: &'static str, descriptor_index: usize, ) -> Self

pub fn first_entity_index(&self) -> usize

pub fn first_position(&self) -> usize

pub fn second_entity_index(&self) -> usize

pub fn second_position(&self) -> usize

pub fn is_intra_list(&self) -> bool

Trait Implementations

impl<S, V> Clone for ListSwapMove<S, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, V: Debug> Debug for ListSwapMove<S, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S, V> Move<S> for ListSwapMove<S, V>

where S: PlanningSolution, V: Clone + PartialEq + Send + Sync + Debug + 'static,

fn is_doable<D: Director<S>>(&self, score_director: &D) -> bool

fn do_move<D: Director<S>>(&self, score_director: &mut D)

fn descriptor_index(&self) -> usize

fn entity_indices(&self) -> &[usize]

fn variable_name(&self) -> &str

impl<S, V, ES> MoveSelector<S, ListSwapMove<S, V>> for ListSwapMoveSelector<S, V, ES>

where S: PlanningSolution, V: Clone + PartialEq + Send + Sync + Debug + 'static, ES: EntitySelector<S>,

fn iter_moves<'a, D: Director<S>>( &'a self, score_director: &'a D, ) -> impl Iterator<Item = ListSwapMove<S, V>> + 'a

fn size<D: Director<S>>(&self, score_director: &D) -> usize

fn is_never_ending(&self) -> bool

impl<S, V, D, ES> MoveSelector<S, ListSwapMove<S, V>> for NearbyListSwapMoveSelector<S, V, D, ES>

where S: PlanningSolution, V: Clone + PartialEq + Send + Sync + Debug + 'static, D: CrossEntityDistanceMeter<S>, ES: EntitySelector<S>,

fn iter_moves<'a, SD: Director<S>>( &'a self, score_director: &'a SD, ) -> impl Iterator<Item = ListSwapMove<S, V>> + 'a

fn size<SD: Director<S>>(&self, score_director: &SD) -> usize

fn is_never_ending(&self) -> bool

impl<S, V> Copy for ListSwapMove<S, V>