use super::{EditChange, EditorSession};
use indicatrix_cut_core::{
Design, Edit, EditError, History, OptimizeOutcome, TierId,
design::{RelationError, TierRelation},
};
use std::{fmt, time::Duration};
#[cfg(test)]
mod tests;
const DRIVEN_ANGLE_TOLERANCE_DEG: f64 = 1e-6;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RelationRefusal {
pub tier: usize,
pub label: String,
pub relation: String,
}
impl fmt::Display for RelationRefusal {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"This angle follows a relation ({} = {}). Edit the relation or remove it.",
self.label, self.relation
)
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum SessionEditError {
Edit(EditError),
Driven(RelationRefusal),
Relation(RelationError),
}
impl fmt::Display for SessionEditError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Edit(error) => fmt::Display::fmt(error, f),
Self::Driven(refusal) => fmt::Display::fmt(refusal, f),
Self::Relation(error) => fmt::Display::fmt(error, f),
}
}
}
impl std::error::Error for SessionEditError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Edit(error) => Some(error),
Self::Driven(_) => None,
Self::Relation(error) => Some(error),
}
}
}
impl From<EditError> for SessionEditError {
fn from(error: EditError) -> Self {
Self::Edit(error)
}
}
impl From<RelationError> for SessionEditError {
fn from(error: RelationError) -> Self {
Self::Relation(error)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ClearedRelation {
pub tier: String,
pub relation: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RelationNotice {
pub cleared: Vec<ClearedRelation>,
}
impl fmt::Display for RelationNotice {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let list = self
.cleared
.iter()
.map(|cleared| {
format!(
"{} (was {} = {})",
cleared.tier, cleared.tier, cleared.relation
)
})
.collect::<Vec<_>>()
.join(", ");
if self.cleared.len() == 1 {
write!(
f,
"{list} no longer follows a relation because a tier it read was removed. \
It keeps its current angle."
)
} else {
write!(
f,
"{list} no longer follow a relation because a tier they read was removed. \
They keep their current angles."
)
}
}
}
fn sets_a_relation(edit: &Edit) -> bool {
match edit {
Edit::SetTierRelation {
relation: Some(_), ..
} => true,
Edit::ReplaceSchedule(state) => !state.tier_relations.is_empty(),
Edit::Batch(edits) => edits.iter().any(sets_a_relation),
_ => false,
}
}
fn replaces_the_schedule(edit: &Edit) -> bool {
match edit {
Edit::ReplaceSchedule(_) => true,
Edit::Batch(edits) => edits.iter().any(replaces_the_schedule),
_ => false,
}
}
fn refuse_direct_change_of_driven(before: &Design, trial: &Design) -> Result<(), SessionEditError> {
for id in before.tier_relations.keys() {
if !trial.tier_relations.contains_key(id) {
continue;
}
let (Some(was), Some(now)) = (before.index_of_tier_id(*id), trial.index_of_tier_id(*id))
else {
continue;
};
let moved = (trial.tiers[now].angle_deg - before.tiers[was].angle_deg).abs();
if moved > DRIVEN_ANGLE_TOLERANCE_DEG {
return Err(SessionEditError::Driven(RelationRefusal {
tier: was,
label: before.relation_label(was),
relation: before.relation_text(was).unwrap_or_default(),
}));
}
}
Ok(())
}
fn state_after_schedule_replacement(design: &Design, edit: &Edit) -> Option<Design> {
if !replaces_the_schedule(edit) {
return None;
}
match edit {
Edit::Batch(edits) => {
let mut running = design.clone();
let mut baseline = None;
for part in edits {
if let Some(found) = state_after_schedule_replacement(&running, part) {
baseline = Some(found);
}
running.apply_edit(part.clone()).ok()?;
}
baseline
}
replacement => {
let mut after = design.clone();
after.apply_edit(replacement.clone()).ok()?;
Some(after)
}
}
}
impl EditorSession {
pub fn try_apply(&mut self, edit: Edit) -> Result<EditChange, SessionEditError> {
self.try_apply_mapped(edit, None).map(|(change, _)| change)
}
pub fn try_apply_mapped(
&mut self,
edit: Edit,
label: Option<&str>,
) -> Result<(EditChange, super::TierIndexMap), SessionEditError> {
self.expire_relation_notice();
let before = self.tier_counts();
let (edit, notice) = self.with_relations_folded(edit)?;
let renumbering = super::TierIndexMap::of(&edit);
let applied = match label {
Some(label) => self.history.apply_labeled(&mut self.design, edit, label),
None => self.history.apply(&mut self.design, edit),
};
applied.map_err(SessionEditError::Edit)?;
self.keep_relation_notice(notice);
let change = self.record_change(before, Some(&renumbering));
Ok((change, renumbering))
}
pub fn try_apply_coalescing(
&mut self,
edit: Edit,
key: u64,
now: Duration,
) -> Result<EditChange, SessionEditError> {
self.expire_relation_notice();
let before = self.tier_counts();
let (edit, notice) = self.with_relations_folded(edit)?;
let renumbering = super::TierIndexMap::of(&edit);
self.history
.apply_coalescing(&mut self.design, edit, key, now)
.map_err(SessionEditError::Edit)?;
self.keep_relation_notice(notice);
Ok(self.record_change(before, Some(&renumbering)))
}
pub(super) fn legacy_edit_error(&mut self, error: SessionEditError) -> EditError {
let tier_count = self.design.tiers.len();
match error {
SessionEditError::Edit(error) => error,
refusal => {
let index = match &refusal {
SessionEditError::Driven(driven) => driven.tier,
_ => 0,
};
self.refusal = Some(refusal);
EditError { index, tier_count }
}
}
}
pub const fn take_refusal(&mut self) -> Option<SessionEditError> {
self.refusal.take()
}
pub const fn take_relation_notice(&mut self) -> Option<RelationNotice> {
self.relation_notice.take()
}
pub(super) fn expire_relation_notice(&mut self) {
if !self.notice_command_open {
self.relation_notice = None;
}
}
pub(super) fn begin_relation_notice_command(&mut self) {
self.relation_notice = None;
self.notice_command_open = true;
}
pub(super) const fn end_relation_notice_command(&mut self) {
self.notice_command_open = false;
}
fn keep_relation_notice(&mut self, notice: Option<RelationNotice>) {
if let Some(notice) = notice {
self.add_relation_notice(notice);
}
}
fn with_relations_folded(
&self,
edit: Edit,
) -> Result<(Edit, Option<RelationNotice>), SessionEditError> {
if self.design.tier_relations.is_empty() && !sets_a_relation(&edit) {
return Ok((edit, None));
}
let mut trial = self.design.clone();
if trial.apply_edit(edit.clone()).is_err() {
return Ok((edit, None));
}
let replaced = state_after_schedule_replacement(&self.design, &edit);
refuse_direct_change_of_driven(replaced.as_ref().unwrap_or(&self.design), &trial)?;
let (clears, notice) = self.dangling_relation_clears(&mut trial);
let updates = trial
.evaluate_relations()
.map_err(SessionEditError::Relation)?;
let changes: Vec<(usize, f64, f64)> = updates
.into_iter()
.filter_map(|(position, new_deg)| {
let old_deg = trial.tiers.get(position)?.angle_deg;
(old_deg.to_bits() != new_deg.to_bits()).then_some((position, old_deg, new_deg))
})
.collect();
if clears.is_empty() && changes.is_empty() {
return Ok((edit, None));
}
let mut edits = Vec::with_capacity(2 + clears.len());
edits.push(edit);
edits.extend(clears);
if !changes.is_empty() {
edits.push(Edit::RetargetAngles { changes });
}
Ok((Edit::Batch(edits), notice))
}
fn dangling_relation_clears(&self, trial: &mut Design) -> (Vec<Edit>, Option<RelationNotice>) {
let mut dangling: Vec<(TierId, usize)> = trial
.tier_relations
.iter()
.filter(|(_, relation)| {
relation
.references()
.iter()
.any(|reference| trial.index_of_tier_id(*reference).is_none())
})
.filter_map(|(id, _)| trial.index_of_tier_id(*id).map(|position| (*id, position)))
.collect();
dangling.sort_by_key(|&(_, position)| position);
let mut clears = Vec::with_capacity(dangling.len());
let mut cleared = Vec::with_capacity(dangling.len());
for (id, position) in dangling {
let before = self.design.index_of_tier_id(id);
let describe = |design: &Design, index: usize| {
(design.relation_label(index), design.relation_text(index))
};
let (tier, relation) = before.map_or_else(
|| describe(trial, position),
|index| describe(&self.design, index),
);
cleared.push(ClearedRelation {
tier,
relation: relation.unwrap_or_default(),
});
trial.tier_relations.remove(&id);
clears.push(Edit::SetTierRelation {
index: position,
relation: None,
});
}
let notice = (!cleared.is_empty()).then_some(RelationNotice { cleared });
(clears, notice)
}
fn add_relation_notice(&mut self, notice: RelationNotice) {
match &mut self.relation_notice {
Some(waiting) => waiting.cleared.extend(notice.cleared),
None => self.relation_notice = Some(notice),
}
}
pub fn set_tier_relation(
&mut self,
tier: usize,
text: &str,
) -> Result<Option<EditChange>, SessionEditError> {
self.design.check_relation_target(tier)?;
let relation = self.design.parse_relation(text)?;
if self.design.tier_relation(tier) == Some(&relation) {
return Ok(None);
}
self.try_apply(Edit::SetTierRelation {
index: tier,
relation: Some(relation),
})
.map(Some)
}
pub fn clear_tier_relation(
&mut self,
tier: usize,
) -> Result<Option<EditChange>, SessionEditError> {
if self.design.tier_relation(tier).is_none() {
return Ok(None);
}
self.try_apply(Edit::SetTierRelation {
index: tier,
relation: None,
})
.map(Some)
}
#[must_use]
pub fn tier_relation_display(&self, tier: usize) -> Option<String> {
self.design.relation_text(tier)
}
#[must_use]
pub fn is_driven(&self, tier: usize) -> bool {
self.design.is_tier_driven(tier)
}
#[must_use]
pub fn drivers_of(&self, tier: usize) -> Vec<usize> {
self.design.relation_drivers(tier)
}
#[must_use]
pub fn dependants_of(&self, tier: usize) -> Vec<usize> {
self.design.relation_dependants(tier)
}
pub(super) fn apply_optimize_outcome_with_relations(
&mut self,
outcome: &OptimizeOutcome,
) -> Result<usize, EditError> {
let mut scratch = self.design.clone();
let mut scratch_history = History::new();
let applied = match indicatrix_cut_core::apply_optimize_outcome(
&mut scratch_history,
&mut scratch,
outcome,
) {
Ok(applied) => applied,
Err(error) => {
self.generation
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
return Err(error);
}
};
if applied == 0 {
return Ok(0);
}
let edits: Vec<Edit> = scratch
.tiers
.iter()
.enumerate()
.filter(|(index, tier)| self.design.tiers.get(*index) != Some(*tier))
.map(|(index, tier)| Edit::ModifyTier {
index,
tier: tier.clone(),
})
.collect();
if edits.is_empty() {
return Ok(0);
}
match self.try_apply(Edit::Batch(edits)) {
Ok(_) => Ok(applied),
Err(error) => {
self.generation
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
Err(self.legacy_edit_error(error))
}
}
}
}
#[must_use]
pub(super) fn linked_rung_relation(
first: TierId,
rung: usize,
step_deg: f64,
side: f64,
) -> TierRelation {
let delta = indicatrix_cut_core::design::snap_noise(rung as f64 * step_deg * side);
TierRelation::new(indicatrix_cut_core::design::RelationExpr::offset_from(
first, delta,
))
}