use indicatrix_cut_core::Edit;
use std::collections::BTreeSet;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Shift {
Insert(usize),
Remove(usize),
Move { from: usize, to: usize },
Clear,
}
impl Shift {
const fn apply(self, index: usize) -> Option<usize> {
match self {
Self::Clear => None,
Self::Insert(at) => Some(if index >= at { index + 1 } else { index }),
Self::Remove(at) => {
if index == at {
None
} else if index > at {
Some(index - 1)
} else {
Some(index)
}
}
Self::Move { from, to } => {
if index == from {
return Some(to);
}
let without_moved = if index > from { index - 1 } else { index };
Some(if without_moved >= to {
without_moved + 1
} else {
without_moved
})
}
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct TierIndexMap {
shifts: Vec<Shift>,
concave_shifts: Vec<Shift>,
}
impl TierIndexMap {
#[must_use]
pub fn of(edit: &Edit) -> Self {
let mut map = Self::default();
collect_shifts(edit, &mut map);
map
}
#[must_use]
pub fn map_concave(&self, index: usize) -> Option<usize> {
self.concave_shifts
.iter()
.try_fold(index, |current, shift| shift.apply(current))
}
#[must_use]
pub fn map(&self, index: usize) -> Option<usize> {
self.shifts
.iter()
.try_fold(index, |current, shift| shift.apply(current))
}
#[must_use]
pub fn remap(&self, selection: &BTreeSet<usize>) -> BTreeSet<usize> {
selection
.iter()
.filter_map(|&index| self.map(index))
.collect()
}
pub fn extend(&mut self, later: &Self) {
self.shifts.extend_from_slice(&later.shifts);
self.concave_shifts.extend_from_slice(&later.concave_shifts);
}
#[must_use]
pub fn map_table_row(
&self,
row: usize,
flat_before: usize,
flat_after: usize,
concave_after: usize,
) -> Option<usize> {
if row < flat_before {
return self.map(row).filter(|&mapped| mapped < flat_after);
}
self.map_concave(row - flat_before)
.filter(|&mapped| mapped < concave_after)
.map(|mapped| flat_after + mapped)
}
}
fn collect_shifts(edit: &Edit, map: &mut TierIndexMap) {
match edit {
Edit::AddTier { index, .. } => map.shifts.push(Shift::Insert(*index)),
Edit::RemoveTier { index } => map.shifts.push(Shift::Remove(*index)),
Edit::MoveTier { from, to } => map.shifts.push(Shift::Move {
from: *from,
to: *to,
}),
Edit::AddConcaveTier { index, .. } => map.concave_shifts.push(Shift::Insert(*index)),
Edit::RemoveConcaveTier { index } => map.concave_shifts.push(Shift::Remove(*index)),
Edit::MoveConcaveTier { from, to } => map.concave_shifts.push(Shift::Move {
from: *from,
to: *to,
}),
Edit::ReplaceSchedule(_) => map.shifts.push(Shift::Clear),
Edit::Batch(edits) => {
for sub_edit in edits {
collect_shifts(sub_edit, map);
}
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use indicatrix::geometry::meet_solver::MeetConstraint;
use indicatrix_cut_core::ConstraintTier;
fn tier() -> ConstraintTier {
ConstraintTier {
angle_deg: -40.0,
name: String::new(),
indices: Vec::new(),
constraint: MeetConstraint::MeetExisting,
imported_meet: None,
original_notes: None,
detached: Vec::new(),
}
}
#[test]
fn an_insertion_pushes_the_rows_at_and_after_it_down() {
let map = TierIndexMap::of(&Edit::AddTier {
index: 2,
tier: tier(),
});
assert_eq!(
[0, 1, 2, 3].map(|index| map.map(index)),
[Some(0), Some(1), Some(3), Some(4)]
);
}
#[test]
fn a_removal_drops_its_row_and_pulls_later_rows_up() {
let map = TierIndexMap::of(&Edit::RemoveTier { index: 1 });
assert_eq!(
[0, 1, 2, 3].map(|index| map.map(index)),
[Some(0), None, Some(1), Some(2)]
);
}
#[test]
fn a_move_follows_remove_then_insert() {
let down = TierIndexMap::of(&Edit::MoveTier { from: 0, to: 2 });
assert_eq!(
[0, 1, 2, 3, 4].map(|index| down.map(index)),
[Some(2), Some(0), Some(1), Some(3), Some(4)]
);
let up = TierIndexMap::of(&Edit::MoveTier { from: 3, to: 1 });
assert_eq!(
[0, 1, 2, 3, 4].map(|index| up.map(index)),
[Some(0), Some(2), Some(3), Some(1), Some(4)]
);
}
#[test]
fn a_batch_composes_its_parts_in_order() {
let undo_of_removal = Edit::Batch(vec![
Edit::AddTier {
index: 1,
tier: tier(),
},
Edit::RestoreTierId {
index: 1,
id: indicatrix_cut_core::TierId(9),
},
]);
let map = TierIndexMap::of(&undo_of_removal);
assert_eq!(
[0, 1, 2].map(|index| map.map(index)),
[Some(0), Some(2), Some(3)]
);
}
#[test]
fn tier_index_map_is_identity_for_concave_edits() {
use indicatrix_cut_core::{
TierId,
design::{ConcaveTier, ConcaveTool, ToolMotion},
};
let concave = ConcaveTier {
name: "Groove".to_owned(),
angle_deg: -40.0,
indices: vec![0.0],
instructions: String::new(),
tool: ConcaveTool::Cylinder,
tool_azimuth_deg: 0.0,
displacement: [0.0; 3],
diameter_ratio: 0.5,
tool_angle_deg: None,
motion: ToolMotion::Reciprocating,
};
let edits = [
Edit::AddConcaveTier {
index: 0,
tier: concave.clone(),
},
Edit::RemoveConcaveTier { index: 0 },
Edit::ModifyConcaveTier {
index: 0,
tier: concave,
},
Edit::MoveConcaveTier { from: 0, to: 1 },
Edit::RestoreConcaveTierId {
index: 0,
id: TierId(3),
},
Edit::RestoreConcaveIndices {
tiers: vec![(0, vec![1.0])],
},
];
for edit in &edits {
let map = TierIndexMap::of(edit);
assert_eq!(
[0, 1, 2, 3].map(|index| map.map(index)),
[Some(0), Some(1), Some(2), Some(3)],
"{edit:?} must not move flat rows"
);
}
}
#[test]
fn edits_that_do_not_move_rows_leave_the_selection_alone() {
let map = TierIndexMap::of(&Edit::RetargetAngles {
changes: vec![(1, -40.0, -41.0)],
});
let selection = BTreeSet::from([0, 2, 4]);
assert_eq!(map.remap(&selection), selection);
}
#[test]
fn relation_edits_move_no_rows_and_leave_a_batch_to_its_other_parts() {
use indicatrix_cut_core::{
TierId,
design::{RelationExpr, TierRelation},
};
let relation = TierRelation::new(RelationExpr::offset_from(TierId(0), -2.0));
for edit in [
Edit::SetTierRelation {
index: 1,
relation: Some(relation),
},
Edit::SetTierRelation {
index: 1,
relation: None,
},
] {
let map = TierIndexMap::of(&edit);
assert_eq!(
[0, 1, 2, 3].map(|index| map.map(index)),
[Some(0), Some(1), Some(2), Some(3)],
"{edit:?} must not move rows"
);
}
let batch = Edit::Batch(vec![
Edit::RemoveTier { index: 0 },
Edit::SetTierRelation {
index: 0,
relation: None,
},
Edit::RetargetAngles {
changes: vec![(0, -40.0, -41.0)],
},
]);
let map = TierIndexMap::of(&batch);
assert_eq!(
[0, 1, 2].map(|index| map.map(index)),
[None, Some(0), Some(1)]
);
}
#[test]
fn remapping_a_selection_drops_removed_rows_and_renumbers_the_rest() {
let map = TierIndexMap::of(&Edit::RemoveTier { index: 0 });
assert_eq!(
map.remap(&BTreeSet::from([0, 1])),
BTreeSet::from([0]),
"row 0 is gone and row 1 is now row 0"
);
}
#[test]
fn replacing_the_whole_schedule_drops_every_selected_row() {
let design = indicatrix_cut_core::Design::fresh(
indicatrix_cut_core::PreformSpec::block(1.0, 1.0, 2.0),
96,
4,
1.62,
);
let replace =
Edit::ReplaceSchedule(Box::new(indicatrix_cut_core::ScheduleState::of(&design)));
let map = TierIndexMap::of(&replace);
assert_eq!(
[0, 1, 2].map(|index| map.map(index)),
[None, None, None],
"no row can be followed through a whole-list replacement"
);
assert!(map.remap(&BTreeSet::from([0, 2])).is_empty());
assert_eq!(map.map_concave(1), Some(1));
}
#[test]
fn concave_edits_renumber_the_concave_list_only() {
let concave = indicatrix_cut_core::Design::concave_fixture()
.concave_tiers
.remove(0);
let insert = TierIndexMap::of(&Edit::AddConcaveTier {
index: 1,
tier: concave,
});
assert_eq!(
[0, 1, 2].map(|index| insert.map_concave(index)),
[Some(0), Some(2), Some(3)]
);
let remove = TierIndexMap::of(&Edit::RemoveConcaveTier { index: 0 });
assert_eq!(
[0, 1].map(|index| remove.map_concave(index)),
[None, Some(0)]
);
let mv = TierIndexMap::of(&Edit::MoveConcaveTier { from: 0, to: 1 });
assert_eq!(
[0, 1, 2].map(|index| mv.map_concave(index)),
[Some(1), Some(0), Some(2)]
);
let flat = TierIndexMap::of(&Edit::RemoveTier { index: 0 });
assert_eq!(flat.map_concave(0), Some(0));
}
#[test]
fn two_changes_extended_into_one_map_move_a_row_like_the_changes_in_turn() {
let mut both = TierIndexMap::of(&Edit::MoveTier { from: 3, to: 0 });
both.extend(&TierIndexMap::of(&Edit::RemoveTier { index: 2 }));
assert_eq!(
[0, 1, 2, 3].map(|index| both.map(index)),
[Some(1), None, Some(2), Some(0)]
);
let first = TierIndexMap::of(&Edit::MoveTier { from: 3, to: 0 });
let second = TierIndexMap::of(&Edit::RemoveTier { index: 2 });
for index in 0..4 {
assert_eq!(
both.map(index),
first.map(index).and_then(|moved| second.map(moved))
);
}
let mut concave = TierIndexMap::of(&Edit::RemoveConcaveTier { index: 0 });
concave.extend(&TierIndexMap::of(&Edit::RemoveConcaveTier { index: 0 }));
assert_eq!(
[0, 1, 2].map(|index| concave.map_concave(index)),
[None, None, Some(0)]
);
}
#[test]
fn a_table_row_follows_its_tier_whether_it_is_flat_or_concave() {
let mut map = TierIndexMap::of(&Edit::RemoveTier { index: 1 });
let concave = indicatrix_cut_core::Design::concave_fixture()
.concave_tiers
.remove(0);
map.extend(&TierIndexMap::of(&Edit::AddConcaveTier {
index: 0,
tier: concave,
}));
let after = |row| map.map_table_row(row, 4, 3, 3);
assert_eq!([0, 1, 2, 3].map(after), [Some(0), None, Some(1), Some(2)]);
assert_eq!([4, 5].map(after), [Some(4), Some(5)]);
assert_eq!(after(6), None);
}
#[test]
fn a_table_row_that_lands_outside_the_new_table_is_dropped() {
let map = TierIndexMap::of(&Edit::AddTier {
index: 0,
tier: tier(),
});
assert_eq!(map.map_table_row(2, 3, 4, 0), Some(3));
assert_eq!(
map.map_table_row(2, 3, 3, 0),
None,
"row 3 does not exist in a table of three"
);
}
}