use std::fmt;
use std::marker::PhantomData;
use solverforge_core::domain::{
DynamicListVariableSlot, DynamicScalarVariableSlot, SolutionDescriptor,
};
use super::{ConflictRepair, ListVariableSlot, ScalarGroupBinding, ScalarVariableSlot};
pub enum VariableSlot<S, V, DM, IDM> {
Scalar(ScalarVariableSlot<S>),
List(ListVariableSlot<S, V, DM, IDM>),
DynamicScalar(DynamicScalarVariableSlot<S>),
DynamicList(DynamicListVariableSlot<S>),
}
impl<S, V, DM: Clone, IDM: Clone> Clone for VariableSlot<S, V, DM, IDM> {
fn clone(&self) -> Self {
match self {
Self::Scalar(variable) => Self::Scalar(*variable),
Self::List(variable) => Self::List(variable.clone()),
Self::DynamicScalar(variable) => Self::DynamicScalar(variable.clone()),
Self::DynamicList(variable) => Self::DynamicList(variable.clone()),
}
}
}
impl<S, V, DM: fmt::Debug, IDM: fmt::Debug> fmt::Debug for VariableSlot<S, V, DM, IDM> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Scalar(variable) => variable.fmt(f),
Self::List(variable) => variable.fmt(f),
Self::DynamicScalar(variable) => variable.fmt(f),
Self::DynamicList(variable) => variable.fmt(f),
}
}
}
pub struct RuntimeModel<S, V, DM, IDM> {
variables: Vec<VariableSlot<S, V, DM, IDM>>,
scalar_groups: Vec<ScalarGroupBinding<S>>,
conflict_repairs: Vec<ConflictRepair<S>>,
_phantom: PhantomData<(fn() -> S, fn() -> V)>,
}
impl<S, V, DM: Clone, IDM: Clone> Clone for RuntimeModel<S, V, DM, IDM> {
fn clone(&self) -> Self {
Self {
variables: self.variables.clone(),
scalar_groups: self.scalar_groups.clone(),
conflict_repairs: self.conflict_repairs.clone(),
_phantom: PhantomData,
}
}
}
impl<S, V, DM, IDM> RuntimeModel<S, V, DM, IDM> {
pub fn new(variables: Vec<VariableSlot<S, V, DM, IDM>>) -> Self {
Self {
variables,
scalar_groups: Vec::new(),
conflict_repairs: Vec::new(),
_phantom: PhantomData,
}
}
pub fn with_scalar_groups(mut self, groups: Vec<ScalarGroupBinding<S>>) -> Self {
self.scalar_groups = groups;
self
}
pub fn with_conflict_repairs(mut self, repairs: Vec<ConflictRepair<S>>) -> Self {
self.conflict_repairs = repairs;
self
}
pub fn resolve_dynamic_descriptor_indexes(
mut self,
descriptor: &SolutionDescriptor,
) -> Result<Self, String> {
for variable in &mut self.variables {
match variable {
VariableSlot::DynamicScalar(slot) => slot.resolve_descriptor_index(descriptor)?,
VariableSlot::DynamicList(slot) => slot.resolve_descriptor_index(descriptor)?,
VariableSlot::Scalar(_) | VariableSlot::List(_) => {}
}
}
Ok(self)
}
pub fn assert_dynamic_descriptor_indexes_resolved(&self) {
for variable in &self.variables {
match variable {
VariableSlot::DynamicScalar(slot) => {
let _ = slot.descriptor_index();
}
VariableSlot::DynamicList(slot) => {
let _ = slot.descriptor_index();
}
VariableSlot::Scalar(_) | VariableSlot::List(_) => {}
}
}
}
pub fn variables(&self) -> &[VariableSlot<S, V, DM, IDM>] {
&self.variables
}
pub fn scalar_groups(&self) -> &[ScalarGroupBinding<S>] {
&self.scalar_groups
}
pub fn conflict_repairs(&self) -> &[ConflictRepair<S>] {
&self.conflict_repairs
}
pub fn is_empty(&self) -> bool {
self.variables.is_empty()
}
pub fn has_list_variables(&self) -> bool {
self.variables.iter().any(|variable| {
matches!(
variable,
VariableSlot::List(_) | VariableSlot::DynamicList(_)
)
})
}
pub fn has_scalar_variables(&self) -> bool {
self.variables.iter().any(|variable| {
matches!(
variable,
VariableSlot::Scalar(_) | VariableSlot::DynamicScalar(_)
)
})
}
pub fn has_dynamic_variables(&self) -> bool {
self.variables.iter().any(|variable| {
matches!(
variable,
VariableSlot::DynamicScalar(_) | VariableSlot::DynamicList(_)
)
})
}
pub fn has_dynamic_list_variables(&self) -> bool {
self.variables
.iter()
.any(|variable| matches!(variable, VariableSlot::DynamicList(_)))
}
pub fn is_scalar_only(&self) -> bool {
self.has_scalar_variables() && !self.has_list_variables()
}
pub fn has_nearby_scalar_change_variables(&self) -> bool {
self.scalar_variables()
.any(ScalarVariableSlot::supports_nearby_change)
}
pub fn has_nearby_scalar_swap_variables(&self) -> bool {
self.scalar_variables()
.any(ScalarVariableSlot::supports_nearby_swap)
}
pub fn assignment_scalar_groups(
&self,
) -> impl Iterator<Item = (usize, &ScalarGroupBinding<S>)> {
self.scalar_groups
.iter()
.enumerate()
.filter(|(_, group)| group.is_assignment())
}
pub fn assignment_group_covers_scalar_variable(
&self,
variable: &ScalarVariableSlot<S>,
) -> bool {
self.assignment_scalar_groups().any(|(_, group)| {
group.members.iter().any(|member| {
member.descriptor_index == variable.descriptor_index
&& member.variable_index == variable.variable_index
})
})
}
pub fn has_scalar_groups(&self) -> bool {
!self.scalar_groups.is_empty()
}
pub fn has_assignment_scalar_groups(&self) -> bool {
self.assignment_scalar_groups().next().is_some()
}
pub fn candidate_scalar_groups(&self) -> impl Iterator<Item = (usize, &ScalarGroupBinding<S>)> {
self.scalar_groups
.iter()
.enumerate()
.filter(|(_, group)| group.is_candidate_group())
}
pub fn has_candidate_scalar_groups(&self) -> bool {
self.candidate_scalar_groups().next().is_some()
}
pub fn has_list_ruin_variables(&self) -> bool {
self.list_variables().any(ListVariableSlot::supports_ruin)
}
pub fn list_precedence_variables(
&self,
) -> impl Iterator<Item = &ListVariableSlot<S, V, DM, IDM>> {
self.list_variables()
.filter(|variable| variable.supports_precedence_moves())
}
pub fn has_list_precedence_variables(&self) -> bool {
self.list_precedence_variables().next().is_some()
}
pub fn has_k_opt_variables(&self) -> bool {
self.list_variables().any(ListVariableSlot::supports_k_opt)
}
pub fn has_conflict_repairs(&self) -> bool {
!self.conflict_repairs.is_empty()
}
pub fn scalar_variables(&self) -> impl Iterator<Item = &ScalarVariableSlot<S>> {
self.variables.iter().filter_map(|variable| match variable {
VariableSlot::Scalar(ctx) => Some(ctx),
VariableSlot::List(_)
| VariableSlot::DynamicScalar(_)
| VariableSlot::DynamicList(_) => None,
})
}
pub fn dynamic_scalar_variables(&self) -> impl Iterator<Item = &DynamicScalarVariableSlot<S>> {
self.variables.iter().filter_map(|variable| match variable {
VariableSlot::DynamicScalar(ctx) => Some(ctx),
VariableSlot::Scalar(_) | VariableSlot::List(_) | VariableSlot::DynamicList(_) => None,
})
}
pub fn scalar_variable_target(
&self,
entity_class: Option<&str>,
variable_name: Option<&str>,
) -> Result<ScalarVariableSlot<S>, String> {
let mut matches = self
.scalar_variables()
.filter(|slot| slot.matches_target(entity_class, variable_name));
let Some(first) = matches.next().copied() else {
return Err(match (entity_class, variable_name) {
(Some(entity), Some(variable)) => {
format!("no scalar variable `{entity}.{variable}` exists in the runtime model")
}
(Some(entity), None) => {
format!("no scalar variable for entity `{entity}` exists in the runtime model")
}
(None, Some(variable)) => {
format!("no scalar variable named `{variable}` exists in the runtime model")
}
(None, None) => {
"exhaustive search requires exactly one scalar variable or an explicit target"
.to_string()
}
});
};
if matches.next().is_some() {
return Err(
"exhaustive search target is ambiguous; specify entity_class and variable_name"
.to_string(),
);
}
Ok(first)
}
pub fn finite_scalar_candidate_space_estimate(
&self,
solution: &S,
slot: ScalarVariableSlot<S>,
value_candidate_limit: Option<usize>,
) -> Option<usize> {
let entity_count = (slot.entity_count)(solution);
let mut total: usize = 1;
for entity_index in 0..entity_count {
let candidate_count = slot
.candidate_values_for_entity(solution, entity_index, value_candidate_limit)
.len();
if candidate_count == 0 {
return Some(0);
}
total = total.checked_mul(candidate_count)?;
}
Some(total)
}
pub fn list_variables(&self) -> impl Iterator<Item = &ListVariableSlot<S, V, DM, IDM>> {
self.variables.iter().filter_map(|variable| match variable {
VariableSlot::List(ctx) => Some(ctx),
VariableSlot::Scalar(_)
| VariableSlot::DynamicScalar(_)
| VariableSlot::DynamicList(_) => None,
})
}
pub fn dynamic_list_variables(&self) -> impl Iterator<Item = &DynamicListVariableSlot<S>> {
self.variables.iter().filter_map(|variable| match variable {
VariableSlot::DynamicList(ctx) => Some(ctx),
VariableSlot::Scalar(_) | VariableSlot::List(_) | VariableSlot::DynamicScalar(_) => {
None
}
})
}
}
impl<S, V, DM: fmt::Debug, IDM: fmt::Debug> fmt::Debug for RuntimeModel<S, V, DM, IDM> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RuntimeModel")
.field("variables", &self.variables)
.field("scalar_groups", &self.scalar_groups)
.field("conflict_repairs", &self.conflict_repairs)
.finish()
}
}
#[cfg(test)]
mod tests {
use solverforge_core::domain::{
DynamicListVariableSlot, DynamicModelBackend, DynamicScalarVariableSlot, EntityClassId,
VariableId,
};
use solverforge_core::score::SoftScore;
use super::{RuntimeModel, VariableSlot};
#[derive(Clone)]
struct DynamicRows;
impl DynamicModelBackend for DynamicRows {
type Score = SoftScore;
fn entity_count(&self, _entity: EntityClassId) -> usize {
0
}
fn get_scalar(
&self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
) -> Option<usize> {
None
}
fn set_scalar(
&mut self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
_value: Option<usize>,
) {
}
fn list_len(&self, _entity: EntityClassId, _row: usize, _variable: VariableId) -> usize {
0
}
fn list_get(
&self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
_pos: usize,
) -> Option<usize> {
None
}
fn list_insert(
&mut self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
_pos: usize,
_value: usize,
) {
}
fn list_remove(
&mut self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
_pos: usize,
) -> Option<usize> {
None
}
fn candidate_values(
&self,
_entity: EntityClassId,
_row: usize,
_variable: VariableId,
) -> &[usize] {
&[]
}
}
#[test]
fn runtime_model_tracks_dynamic_variable_slots() {
let scalar =
DynamicScalarVariableSlot::new(EntityClassId(0), VariableId(0), "Task", "worker", true);
let list =
DynamicListVariableSlot::new(EntityClassId(1), VariableId(0), "Vehicle", "visits");
let model: RuntimeModel<DynamicRows, usize, (), ()> = RuntimeModel::new(vec![
VariableSlot::DynamicScalar(scalar.clone()),
VariableSlot::DynamicList(list.clone()),
]);
assert!(model.has_scalar_variables());
assert!(model.has_list_variables());
assert_eq!(
model
.dynamic_scalar_variables()
.map(|slot| slot.variable_name)
.collect::<Vec<_>>(),
vec!["worker"]
);
assert_eq!(
model
.dynamic_list_variables()
.map(|slot| slot.variable_name)
.collect::<Vec<_>>(),
vec!["visits"]
);
assert_eq!(model.scalar_variables().count(), 0);
assert_eq!(model.list_variables().count(), 0);
}
#[test]
#[should_panic(
expected = "dynamic scalar variable Task.worker has not been resolved against a SolutionDescriptor"
)]
fn runtime_model_rejects_unresolved_dynamic_slots_for_selector_use() {
let scalar =
DynamicScalarVariableSlot::new(EntityClassId(0), VariableId(0), "Task", "worker", true);
let model: RuntimeModel<DynamicRows, usize, (), ()> =
RuntimeModel::new(vec![VariableSlot::DynamicScalar(scalar)]);
model.assert_dynamic_descriptor_indexes_resolved();
}
}