Struct SubListSwapMove 

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

A move that swaps two contiguous sublists.

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::SubListSwapMove;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

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

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

impl PlanningSolution for Solution {
    type Score = SimpleScore;
    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 sublist_remove(s: &mut Solution, entity_idx: usize, start: usize, end: usize) -> Vec<i32> {
    s.vehicles.get_mut(entity_idx)
        .map(|v| v.visits.drain(start..end).collect())
        .unwrap_or_default()
}
fn sublist_insert(s: &mut Solution, entity_idx: usize, pos: usize, items: Vec<i32>) {
    if let Some(v) = s.vehicles.get_mut(entity_idx) {
        for (i, item) in items.into_iter().enumerate() {
            v.visits.insert(pos + i, item);
        }
    }
}

// Swap [1..3) from vehicle 0 with [0..2) from vehicle 1
let m = SubListSwapMove::<Solution, i32>::new(
    0, 1, 3,  // first: entity 0, range [1, 3)
    1, 0, 2,  // second: entity 1, range [0, 2)
    list_len, sublist_remove, sublist_insert,
    "visits", 0,
);

Implementations

impl<S, V> SubListSwapMove<S, V>

pub fn new( first_entity_index: usize, first_start: usize, first_end: usize, second_entity_index: usize, second_start: usize, second_end: usize, list_len: fn(&S, usize) -> usize, sublist_remove: fn(&mut S, usize, usize, usize) -> Vec<V>, sublist_insert: fn(&mut S, usize, usize, Vec<V>), variable_name: &'static str, descriptor_index: usize, ) -> Self

Creates a new sublist swap move with typed function pointers.

Arguments

• first_entity_index - First entity index
• first_start - Start of first range (inclusive)
• first_end - End of first range (exclusive)
• second_entity_index - Second entity index
• second_start - Start of second range (inclusive)
• second_end - End of second range (exclusive)
• list_len - Function to get list length
• sublist_remove - Function to remove range [start, end)
• sublist_insert - Function to insert elements at position
• variable_name - Name of the list variable
• descriptor_index - Entity descriptor index

pub fn first_entity_index(&self) -> usize

Returns the first entity index.

pub fn first_start(&self) -> usize

Returns the first range start.

pub fn first_end(&self) -> usize

Returns the first range end.

pub fn first_len(&self) -> usize

Returns the first sublist length.

pub fn second_entity_index(&self) -> usize

Returns the second entity index.

pub fn second_start(&self) -> usize

Returns the second range start.

pub fn second_end(&self) -> usize

Returns the second range end.

pub fn second_len(&self) -> usize

Returns the second sublist length.

pub fn is_intra_list(&self) -> bool

Returns true if this is an intra-list swap (same entity).

Trait Implementations

impl<S: Clone, V: Clone> Clone for SubListSwapMove<S, V>

fn clone(&self) -> SubListSwapMove<S, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

fn is_doable(&self, score_director: &dyn ScoreDirector<S>) -> bool

Returns true if this move can be executed in the current state.

fn do_move(&self, score_director: &mut dyn ScoreDirector<S>)

Executes this move, modifying the working solution.

fn descriptor_index(&self) -> usize

Returns the descriptor index of the entity type this move affects.

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

Returns the entity indices involved in this move.

fn variable_name(&self) -> &str

Returns the variable name this move affects.