solverforge_solver/heuristic/selector/
list_reverse.rs

1//! Public static adapter for the canonical list-reverse cursor.
2
3use std::fmt::Debug;
4use std::marker::PhantomData;
5
6use solverforge_core::domain::PlanningSolution;
7use solverforge_scoring::Director;
8
9use crate::heuristic::r#move::ListReverseMove;
10use crate::heuristic::selector::list_kernel::{
11    NativeReverseEmitter, ReverseCursor, STATIC_REVERSE_ENTITY_SALT,
12};
13
14use super::entity::EntitySelector;
15use super::move_selector::{
16    CandidateId, MoveCandidateRef, MoveCursor, MoveSelector, MoveStreamContext,
17};
18
19pub struct ListReverseMoveSelector<S, V, ES> {
20    entity_selector: ES,
21    list_len: fn(&S, usize) -> usize,
22    list_get: fn(&S, usize, usize) -> Option<V>,
23    list_reverse: fn(&mut S, usize, usize, usize),
24    variable_name: &'static str,
25    descriptor_index: usize,
26    _phantom: PhantomData<(fn() -> S, fn() -> V)>,
27}
28
29/// Public cursor facade over the crate-private generic kernel.
30pub struct ListReverseMoveCursor<S, V>
31where
32    S: PlanningSolution,
33    V: Clone + Send + Sync + Debug + 'static,
34{
35    inner: ReverseCursor<S, NativeReverseEmitter<S, V>>,
36}
37
38impl<S, V> ListReverseMoveCursor<S, V>
39where
40    S: PlanningSolution,
41    V: Clone + Send + Sync + Debug + 'static,
42{
43    fn new(inner: ReverseCursor<S, NativeReverseEmitter<S, V>>) -> Self {
44        Self { inner }
45    }
46}
47
48impl<S, V> MoveCursor<S, ListReverseMove<S, V>> for ListReverseMoveCursor<S, V>
49where
50    S: PlanningSolution,
51    V: Clone + Send + Sync + Debug + 'static,
52{
53    fn next_candidate(&mut self) -> Option<CandidateId> {
54        self.inner.next_candidate()
55    }
56
57    fn candidate(&self, id: CandidateId) -> Option<MoveCandidateRef<'_, S, ListReverseMove<S, V>>> {
58        self.inner.candidate(id)
59    }
60
61    fn take_candidate(&mut self, id: CandidateId) -> ListReverseMove<S, V> {
62        self.inner.take_candidate(id)
63    }
64
65    fn next_owned_candidate(&mut self) -> Option<ListReverseMove<S, V>> {
66        self.inner.next_owned_candidate()
67    }
68
69    fn next_owned_candidate_matching(
70        &mut self,
71        predicate: for<'a> fn(MoveCandidateRef<'a, S, ListReverseMove<S, V>>) -> bool,
72    ) -> Option<ListReverseMove<S, V>> {
73        self.inner.next_owned_candidate_matching(predicate)
74    }
75
76    fn release_candidate(&mut self, id: CandidateId) -> bool {
77        self.inner.release_candidate(id)
78    }
79}
80
81impl<S, V> Iterator for ListReverseMoveCursor<S, V>
82where
83    S: PlanningSolution,
84    V: Clone + Send + Sync + Debug + 'static,
85{
86    type Item = ListReverseMove<S, V>;
87
88    fn next(&mut self) -> Option<Self::Item> {
89        self.next_owned_candidate()
90    }
91}
92
93impl<S, V: Debug, ES: Debug> Debug for ListReverseMoveSelector<S, V, ES> {
94    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
95        f.debug_struct("ListReverseMoveSelector")
96            .field("entity_selector", &self.entity_selector)
97            .field("variable_name", &self.variable_name)
98            .field("descriptor_index", &self.descriptor_index)
99            .finish()
100    }
101}
102
103impl<S, V, ES> ListReverseMoveSelector<S, V, ES> {
104    pub fn new(
105        entity_selector: ES,
106        list_len: fn(&S, usize) -> usize,
107        list_get: fn(&S, usize, usize) -> Option<V>,
108        list_reverse: fn(&mut S, usize, usize, usize),
109        variable_name: &'static str,
110        descriptor_index: usize,
111    ) -> Self {
112        Self {
113            entity_selector,
114            list_len,
115            list_get,
116            list_reverse,
117            variable_name,
118            descriptor_index,
119            _phantom: PhantomData,
120        }
121    }
122}
123
124impl<S, V, ES> MoveSelector<S, ListReverseMove<S, V>> for ListReverseMoveSelector<S, V, ES>
125where
126    S: PlanningSolution,
127    V: Clone + Send + Sync + Debug + 'static,
128    ES: EntitySelector<S>,
129{
130    type Cursor<'a>
131        = ListReverseMoveCursor<S, V>
132    where
133        Self: 'a;
134
135    fn open_cursor<'a, D: Director<S>>(&'a self, score_director: &D) -> Self::Cursor<'a> {
136        self.open_cursor_with_context(score_director, MoveStreamContext::default())
137    }
138
139    fn open_cursor_with_context<'a, D: Director<S>>(
140        &'a self,
141        score_director: &D,
142        context: MoveStreamContext,
143    ) -> Self::Cursor<'a> {
144        let canonical_entities = self
145            .entity_selector
146            .iter(score_director)
147            .map(|reference| reference.entity_index)
148            .collect::<Vec<_>>();
149        let salt = STATIC_REVERSE_ENTITY_SALT ^ self.descriptor_index as u64;
150        let entities = (0..canonical_entities.len())
151            .map(|offset| {
152                canonical_entities[context.selection_index(offset, canonical_entities.len(), salt)]
153            })
154            .collect::<Vec<_>>();
155        let solution = score_director.working_solution();
156        let route_lens = entities
157            .iter()
158            .map(|&entity| (self.list_len)(solution, entity))
159            .collect();
160        ListReverseMoveCursor::new(ReverseCursor::new(
161            NativeReverseEmitter::new(
162                self.list_len,
163                self.list_get,
164                self.list_reverse,
165                self.variable_name,
166                self.descriptor_index,
167            ),
168            entities,
169            route_lens,
170            context,
171            self.descriptor_index,
172        ))
173    }
174
175    fn size<D: Director<S>>(&self, score_director: &D) -> usize {
176        let solution = score_director.working_solution();
177        self.entity_selector
178            .iter(score_director)
179            .map(|reference| {
180                let len = (self.list_len)(solution, reference.entity_index);
181                if len >= 2 {
182                    len * (len - 1) / 2
183                } else {
184                    0
185                }
186            })
187            .sum()
188    }
189}
solverforge_solver/heuristic/selector/list_reverse.rs

solverforge_solver/heuristic/selector/
list_reverse.rs
