Struct ListRuinMove 

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

A self-contained list ruin-and-recreate move.

Its public function-pointer constructor remains unchanged. Candidate mutation, restore, undo, owner policy, precedence filtering, and tabu mechanics live in move::list_kernel so runtime list moves reuse the same implementation instead of translating through this facade.

Implementations

impl<S, V> ListRuinMove<S, V>

pub fn new( entity_index: usize, element_indices: &[usize], entity_count: fn(&S) -> usize, list_len: fn(&S, usize) -> usize, list_get: fn(&S, usize, usize) -> Option<V>, list_remove: fn(&mut S, usize, usize) -> V, list_insert: fn(&mut S, usize, usize, V), variable_name: &'static str, descriptor_index: usize, ) -> Self

pub fn with_element_owner_fn( self, element_owner_fn: Option<fn(&S, &V) -> Option<usize>>, ) -> Self

pub fn with_skip_empty_destinations(self, skip_empty_destinations: bool) -> Self

pub fn entity_index(&self) -> usize

pub fn element_indices(&self) -> &[usize]

pub fn ruin_count(&self) -> usize

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

type Undo = SmallVec<[(usize, usize, usize); 8]>

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

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

fn undo_move<D: Director<S>>(&self, score_director: &mut D, undo: Self::Undo)

fn descriptor_index(&self) -> usize

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

fn variable_name(&self) -> &str

fn telemetry_label(&self) -> &'static str

fn tabu_signature<D: Director<S>>( &self, score_director: &D, ) -> MoveTabuSignature

fn requires_hard_improvement(&self) -> bool

fn requires_score_improvement(&self) -> bool

fn candidate_trace_identity(&self) -> Option<CandidateTraceIdentity>

Returns the canonical identity used by opt-in candidate-pull tracing.

fn for_each_affected_entity( &self, visitor: &mut dyn FnMut(MoveAffectedEntity<'_>), )

impl<S, V> MoveCursor<S, ListRuinMove<S, V>> for ListRuinMoveCursor<S, V>

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

fn next_candidate(&mut self) -> Option<CandidateId>

fn candidate( &self, id: CandidateId, ) -> Option<MoveCandidateRef<'_, S, ListRuinMove<S, V>>>

fn take_candidate(&mut self, id: CandidateId) -> ListRuinMove<S, V>

fn next_owned_candidate(&mut self) -> Option<ListRuinMove<S, V>>

fn next_owned_candidate_matching( &mut self, predicate: for<'a> fn(MoveCandidateRef<'a, S, ListRuinMove<S, V>>) -> bool, ) -> Option<ListRuinMove<S, V>>

fn release_candidate(&mut self, id: CandidateId) -> bool

fn next_owned_candidate_inspected<T, F>(&mut self, inspect: F) -> Option<(M, T)>

where F: for<'a> FnMut(MoveCandidateRef<'a, S, M>) -> Option<T>,

fn apply_owned_candidate<D: Director<S>>( &mut self, id: CandidateId, score_director: &mut D, )

fn selector_index(&self, _id: CandidateId) -> Option<usize>

impl<S, V> MoveSelector<S, ListRuinMove<S, V>> for ListRuinMoveSelector<S, V>

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

type Cursor<'a> = ListRuinMoveCursor<S, V> where Self: 'a

fn open_cursor<'a, D: Director<S>>( &'a self, score_director: &D, ) -> Self::Cursor<'a>

fn open_cursor_with_context<'a, D: Director<S>>( &'a self, score_director: &D, context: MoveStreamContext, ) -> Self::Cursor<'a>

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

fn is_never_ending(&self) -> bool

fn validate_cursor<D: Director<S>>(&self, _score_director: &D)

Validates director-dependent selector configuration without producing candidates.

fn iter_moves<'a, D: Director<S>>( &'a self, score_director: &D, ) -> MoveSelectorIter<S, M, Self::Cursor<'a>>

fn append_moves<D: Director<S>>( &self, score_director: &D, arena: &mut MoveArena<M>, )