From cedc2253ca1a7bc360f653af209403cd3be59868 Mon Sep 17 00:00:00 2001 From: Mikolaj Wielgus Date: Tue, 24 Oct 2023 05:04:38 +0000 Subject: [PATCH] primitive,layout: Remove methods that assume order There's should be no previous or next primitive, only this end and the other end. --- src/bow.rs | 8 ++++---- src/draw.rs | 36 ++++++++++++++---------------------- src/layout.rs | 16 ++-------------- src/primitive.rs | 48 ++++++++++++------------------------------------ src/segbend.rs | 20 +++----------------- 5 files changed, 35 insertions(+), 93 deletions(-) diff --git a/src/bow.rs b/src/bow.rs index 1e46cc7..99650b0 100644 --- a/src/bow.rs +++ b/src/bow.rs @@ -20,13 +20,13 @@ impl Bow { pub fn from_bend(index: FixedBendIndex, graph: &StableDiGraph) -> Self { let bend = index; - let seg1_dot2 = FixedBend::new(bend, graph).prev().unwrap(); + let seg1_dot2 = FixedBend::new(bend, graph).ends().0; let seg1 = FixedDot::new(seg1_dot2, graph).seg().unwrap(); - let seg1_dot1 = FixedSeg::new(seg1, graph).prev().unwrap(); + let seg1_dot1 = FixedSeg::new(seg1, graph).other_end(seg1_dot2); - let seg2_dot1 = FixedBend::new(bend, graph).next().unwrap(); + let seg2_dot1 = FixedBend::new(bend, graph).ends().1; let seg2 = FixedDot::new(seg2_dot1, graph).seg().unwrap(); - let seg2_dot2 = FixedSeg::new(seg2, graph).next().unwrap(); + let seg2_dot2 = FixedSeg::new(seg2, graph).other_end(seg2_dot1); Self { seg1_dot1, diff --git a/src/draw.rs b/src/draw.rs index c162137..ea1e8f0 100644 --- a/src/draw.rs +++ b/src/draw.rs @@ -61,7 +61,7 @@ impl<'a> Draw<'a> { } pub fn start(&mut self, from: FixedDotIndex) -> Head { - self.prev_head(from) + self.head(from) } #[debug_ensures(ret.is_ok() -> self.layout.node_count() == old(self.layout.node_count() + 1))] @@ -98,7 +98,7 @@ impl<'a> Draw<'a> { into: FixedDotIndex, width: f64, ) -> Result<(), ()> { - let to_head = self.next_head(into); + let to_head = self.head(into); let to_cw = self.guide(&Default::default()).head_cw(&to_head).unwrap(); let tangent = self .guide(&Default::default()) @@ -272,15 +272,15 @@ impl<'a> Draw<'a> { #[debug_ensures(ret.is_some() -> self.layout.node_count() == old(self.layout.node_count() - 4))] #[debug_ensures(ret.is_none() -> self.layout.node_count() == old(self.layout.node_count()))] pub fn undo_segbend(&mut self, head: SegbendHead) -> Option { - self.layout - .primitive(head.segbend.ends().0) - .prev() - .map(|prev_dot| { - self.layout.remove_interior(&head.segbend); - self.layout.remove(head.dot().into()); + let prev_dot = self + .layout + .primitive(head.segbend.seg) + .other_end(head.segbend.dot); - self.prev_head(prev_dot) - }) + self.layout.remove_interior(&head.segbend); + self.layout.remove(head.dot().into()); + + Some(self.head(prev_dot)) } #[debug_requires(width <= self.layout.primitive(head.dot()).weight().circle.r * 2.0)] @@ -311,19 +311,11 @@ impl<'a> Draw<'a> { self.layout.remove(head.dot.into()); } - fn prev_head(&self, dot: FixedDotIndex) -> Head { - if let Some(segbend) = self.layout.prev_segbend(dot) { - Head::from(SegbendHead { dot, segbend }) + fn head(&self, dot: FixedDotIndex) -> Head { + if let Some(segbend) = self.layout.segbend(dot) { + SegbendHead { dot, segbend }.into() } else { - Head::from(BareHead { dot }) - } - } - - fn next_head(&self, dot: FixedDotIndex) -> Head { - if let Some(segbend) = self.layout.next_segbend(dot) { - Head::from(SegbendHead { dot, segbend }) - } else { - Head::from(BareHead { dot }) + BareHead { dot }.into() } } diff --git a/src/layout.rs b/src/layout.rs index 84e68ea..ff77264 100644 --- a/src/layout.rs +++ b/src/layout.rs @@ -328,22 +328,10 @@ impl Layout { Bow::from_bend(bend, &self.graph) } - pub fn prev_segbend(&self, dot: FixedDotIndex) -> Option { - Segbend::from_dot_prev(dot, &self.graph) + pub fn segbend(&self, dot: FixedDotIndex) -> Option { + Segbend::from_dot(dot, &self.graph) } - pub fn next_segbend(&self, dot: FixedDotIndex) -> Option { - Segbend::from_dot_next(dot, &self.graph) - } - - /*pub fn prev_band(&self, to: FixedDotIndex) -> Option { - Band::from_dot_prev(to, &self.graph) - } - - pub fn next_band(&self, from: FixedDotIndex) -> Option { - Band::from_dot_next(from, &self.graph) - }*/ - #[debug_ensures(ret.is_ok() -> self.graph.node_count() == old(self.graph.node_count()))] #[debug_ensures(ret.is_ok() -> self.graph.edge_count() == old(self.graph.edge_count()))] #[debug_ensures(ret.is_err() -> self.graph.node_count() == old(self.graph.node_count() - 1))] diff --git a/src/primitive.rs b/src/primitive.rs index 3ac0dd2..fcabdb3 100644 --- a/src/primitive.rs +++ b/src/primitive.rs @@ -66,30 +66,6 @@ impl<'a, W> GenericPrimitive<'a, W> { .map(|index| self.graph.node_weight(index).unwrap().retag(index)) } - fn prev_node(&self) -> Option> { - self.graph - .neighbors_directed(self.index.node_index(), Incoming) - .filter(|ni| { - self.graph - .edge_weight(self.graph.find_edge(*ni, self.index.node_index()).unwrap()) - .unwrap() - .is_adjacent() - }) - .next() - } - - fn next_node(&self) -> Option> { - self.graph - .neighbors_directed(self.index.node_index(), Outgoing) - .filter(|ni| { - self.graph - .edge_weight(self.graph.find_edge(self.index.node_index(), *ni).unwrap()) - .unwrap() - .is_adjacent() - }) - .next() - } - pub fn core(&self) -> Option { self.graph .neighbors(self.index.node_index()) @@ -257,12 +233,12 @@ impl<'a> MakeShape for LooseDot<'a> { pub type FixedSeg<'a> = GenericPrimitive<'a, FixedSegWeight>; impl<'a> FixedSeg<'a> { - pub fn next(&self) -> Option { - self.next_node().map(|ni| FixedDotIndex::new(ni)) - } - - pub fn prev(&self) -> Option { - self.prev_node().map(|ni| FixedDotIndex::new(ni)) + pub fn other_end(&self, dot: FixedDotIndex) -> FixedDotIndex { + let ends = self.ends(); + [ends.0, ends.1] + .into_iter() + .find(|end| end.node_index() != dot.node_index()) + .unwrap() } } @@ -358,12 +334,12 @@ impl<'a> FixedBend<'a> { .next() } - pub fn next(&self) -> Option { - self.next_node().map(|ni| FixedDotIndex::new(ni)) - } - - pub fn prev(&self) -> Option { - self.prev_node().map(|ni| FixedDotIndex::new(ni)) + pub fn other_end(&self, dot: FixedDotIndex) -> FixedDotIndex { + let ends = self.ends(); + [ends.0, ends.1] + .into_iter() + .find(|end| end.node_index() != dot.node_index()) + .unwrap() } fn inner_radius(&self) -> f64 { diff --git a/src/segbend.rs b/src/segbend.rs index 1667b7d..7104c47 100644 --- a/src/segbend.rs +++ b/src/segbend.rs @@ -13,27 +13,13 @@ pub struct Segbend { } impl Segbend { - pub fn new(bend: FixedBendIndex, dot: FixedDotIndex, seg: FixedSegIndex) -> Self { - Self { seg, dot, bend } - } - - pub fn from_dot_prev( + pub fn from_dot( dot: FixedDotIndex, graph: &StableDiGraph, ) -> Option { let bend = FixedDot::new(dot, graph).bend()?; - let dot = FixedBend::new(bend, graph).prev().unwrap(); - let seg = FixedDot::new(dot, graph).seg().unwrap(); - Some(Self { bend, dot, seg }) - } - - pub fn from_dot_next( - dot: FixedDotIndex, - graph: &StableDiGraph, - ) -> Option { - let bend = FixedDot::new(dot, graph).bend()?; - let dot = FixedBend::new(bend, graph).next().unwrap(); - let seg = FixedDot::new(dot, graph).seg().unwrap(); + let dot = FixedBend::new(bend, graph).other_end(dot); + let seg = FixedDot::new(dot, graph).seg()?; Some(Self { bend, dot, seg }) } }