Struct SwapMove 

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

A move that swaps values between two entities.

Stores entity indices and typed function pointers for zero-erasure access. Undo is handled by RecordingScoreDirector, not by this move.

Type Parameters

• S - The planning solution type
• V - The variable value type

Example

use solverforge_solver::heuristic::r#move::SwapMove;
use solverforge_core::domain::PlanningSolution;
use solverforge_core::score::SimpleScore;

#[derive(Clone)]
struct Sol { values: Vec<Option<i32>>, score: Option<SimpleScore> }

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

// Typed getter/setter with zero erasure
fn get_v(s: &Sol, idx: usize) -> Option<i32> { s.values.get(idx).copied().flatten() }
fn set_v(s: &mut Sol, idx: usize, v: Option<i32>) { if let Some(x) = s.values.get_mut(idx) { *x = v; } }

// Swap values between entities 0 and 1
let swap = SwapMove::<Sol, i32>::new(0, 1, get_v, set_v, "value", 0);

Implementations

impl<S, V> SwapMove<S, V>

pub fn new( left_entity_index: usize, right_entity_index: usize, getter: fn(&S, usize) -> Option<V>, setter: fn(&mut S, usize, Option<V>), variable_name: &'static str, descriptor_index: usize, ) -> Self

Creates a new swap move with typed function pointers.

Arguments

• left_entity_index - Index of the first entity
• right_entity_index - Index of the second entity
• getter - Typed getter function pointer
• setter - Typed setter function pointer
• variable_name - Name of the variable being swapped
• descriptor_index - Index in the entity descriptor

pub fn left_entity_index(&self) -> usize

Returns the left entity index.

pub fn right_entity_index(&self) -> usize

Returns the right entity index.

Trait Implementations

impl<S, V> Clone for SwapMove<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 SwapMove<S, V>

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

Formats the value using the given formatter.

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

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

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

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

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

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.

impl<S, V, LES, RES> MoveSelector<S, SwapMove<S, V>> for SwapMoveSelector<S, V, LES, RES>

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

fn iter_moves<'a, D: ScoreDirector<S>>( &'a self, score_director: &'a D, ) -> Box<dyn Iterator<Item = SwapMove<S, V>> + 'a>

Returns an iterator over typed moves.

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

Returns the approximate number of moves.

fn is_never_ending(&self) -> bool

Returns true if this selector may return the same move multiple times.

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