primitive: Remove `.tagged_prev()`, `.tagged_next()` methods

Temporarily commented out band code which relied on tem.

src/band.rs

@@ -1,9 +1,4 @@
-use petgraph::stable_graph::StableDiGraph;
+use crate::graph::{Ends, FixedDotIndex, Index, Interior};
-
-use crate::{
-    graph::{DotIndex, Ends, FixedDotIndex, Index, Interior, Label, MakePrimitive, Weight},
-    primitive::TaggedPrevTaggedNext,
-};
 
 pub struct Band {
     from: FixedDotIndex,
@@ -11,7 +6,7 @@ pub struct Band {
     interior: Vec<Index>,
 }
 
-impl Band {
+/*impl Band {
     pub fn from_dot_prev(
         dot: FixedDotIndex,
         graph: &StableDiGraph<Weight, Label, usize>,
@@ -57,7 +52,7 @@ impl Band {
             })
         }
     }
-}
+}*/
 
 impl Interior<Index> for Band {
     fn interior(&self) -> Vec<Index> {

src/bow.rs

@@ -1,10 +1,9 @@
 use petgraph::stable_graph::StableDiGraph;
 
 use crate::graph::{
-    BendIndex, DotIndex, Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior,
+    Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior, Label, Weight,
-    Label, SegIndex, Weight,
 };
-use crate::primitive::{FixedBend, FixedDot, FixedSeg, TaggedPrevTaggedNext};
+use crate::primitive::{FixedBend, FixedDot, FixedSeg};
 
 #[derive(Debug, Clone, Copy)]
 pub struct Bow {
@@ -22,19 +21,11 @@ impl Bow {
         let bend = index;
 
         let seg1_dot2 = FixedBend::new(bend, graph).prev().unwrap();
-        let seg1 = FixedDot::new(seg1_dot2, graph)
+        let seg1 = FixedDot::new(seg1_dot2, graph).seg().unwrap();
-            .tagged_prev()
-            .unwrap()
-            .into_fixed_seg()
-            .unwrap();
         let seg1_dot1 = FixedSeg::new(seg1, graph).prev().unwrap();
 
         let seg2_dot1 = FixedBend::new(bend, graph).next().unwrap();
-        let seg2 = FixedDot::new(seg2_dot1, graph)
+        let seg2 = FixedDot::new(seg2_dot1, graph).seg().unwrap();
-            .tagged_next()
-            .unwrap()
-            .into_fixed_seg()
-            .unwrap();
         let seg2_dot2 = FixedSeg::new(seg2, graph).next().unwrap();
 
         Self {

src/draw.rs

@@ -4,8 +4,8 @@ use geo::{EuclideanLength, Point};
 
 use crate::{
     graph::{
-        BendIndex, DotIndex, Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight,
+        Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegIndex,
-        FixedSegIndex, FixedSegWeight, Index, SegIndex,
+        FixedSegWeight, Index,
     },
     guide::Guide,
     layout::Layout,

src/layout.rs

@@ -6,16 +6,13 @@ use petgraph::Direction::Incoming;
 use rstar::primitives::GeomWithData;
 use rstar::{RTree, RTreeObject};
 
-use crate::band::Band;
 use crate::bow::Bow;
 use crate::graph::{
-    BendIndex, DotIndex, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight,
+    FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegIndex, FixedSegWeight,
-    FixedSegIndex, FixedSegWeight, GenericIndex, GetNodeIndex, HalfLooseSegWeight, Index, Interior,
+    GenericIndex, GetNodeIndex, HalfLooseSegWeight, Index, Interior, Label, LooseDotIndex,
-    Label, LooseDotIndex, LooseDotWeight, MakePrimitive, Retag, SegIndex, Weight,
+    LooseDotWeight, MakePrimitive, Retag, Weight,
-};
-use crate::primitive::{
-    GenericPrimitive, GetConnectable, GetWeight, MakeShape, TaggedPrevTaggedNext,
 };
+use crate::primitive::{GenericPrimitive, GetConnectable, GetWeight, MakeShape};
 use crate::segbend::Segbend;
 use crate::shape::{Shape, ShapeTrait};
 
@@ -339,13 +336,13 @@ impl Layout {
         Segbend::from_dot_next(dot, &self.graph)
     }
 
-    pub fn prev_band(&self, to: FixedDotIndex) -> Option<Band> {
+    /*pub fn prev_band(&self, to: FixedDotIndex) -> Option<Band> {
         Band::from_dot_prev(to, &self.graph)
     }
 
     pub fn next_band(&self, from: FixedDotIndex) -> Option<Band> {
         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()))]
@@ -386,11 +383,11 @@ impl Layout {
     #[debug_ensures(self.graph.edge_count() == old(self.graph.edge_count()))]
     pub fn move_dot(&mut self, dot: FixedDotIndex, to: Point) -> Result<(), ()> {
         self.primitive(dot)
-            .tagged_prev()
+            .seg()
-            .map(|prev| self.remove_from_rtree(prev));
+            .map(|seg| self.remove_from_rtree(seg.into()));
         self.primitive(dot)
-            .tagged_next()
+            .bend()
-            .map(|next| self.remove_from_rtree(next));
+            .map(|bend| self.remove_from_rtree(bend.into()));
         self.remove_from_rtree(dot.into());
 
         let mut dot_weight = self.primitive(dot).weight();
@@ -405,21 +402,21 @@ impl Layout {
 
             self.insert_into_rtree(dot.into());
             self.primitive(dot)
-                .tagged_prev()
+                .seg()
-                .map(|prev| self.insert_into_rtree(prev));
+                .map(|prev| self.insert_into_rtree(prev.into()));
             self.primitive(dot)
-                .tagged_next()
+                .bend()
-                .map(|next| self.insert_into_rtree(next));
+                .map(|next| self.insert_into_rtree(next.into()));
             return Err(());
         }
 
         self.insert_into_rtree(dot.into());
         self.primitive(dot)
-            .tagged_prev()
+            .seg()
-            .map(|prev| self.insert_into_rtree(prev));
+            .map(|prev| self.insert_into_rtree(prev.into()));
         self.primitive(dot)
-            .tagged_next()
+            .bend()
-            .map(|next| self.insert_into_rtree(next));
+            .map(|next| self.insert_into_rtree(next.into()));
 
         Ok(())
     }

src/primitive.rs

@@ -5,7 +5,7 @@ use petgraph::stable_graph::{NodeIndex, StableDiGraph};
 use petgraph::Direction::{Incoming, Outgoing};
 
 use crate::graph::{
-    BendIndex, DotIndex, Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight,
+    Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegIndex,
     FixedSegWeight, FullyLooseSegWeight, GenericIndex, GetNet, GetNodeIndex, HalfLooseSegWeight,
     Index, Interior, Label, LooseBendIndex, LooseBendWeight, LooseDotWeight, MakePrimitive, Retag,
     Weight,
@@ -28,12 +28,6 @@ pub trait GetConnectable: GetNet + GetGraph {
     }
 }
 
-#[enum_dispatch]
-pub trait TaggedPrevTaggedNext {
-    fn tagged_prev(&self) -> Option<Index>;
-    fn tagged_next(&self) -> Option<Index>;
-}
-
 #[enum_dispatch]
 pub trait GetWeight<W> {
     fn weight(&self) -> W;
@@ -174,21 +168,28 @@ where
     }
 }
 
-impl<'a, W> TaggedPrevTaggedNext for GenericPrimitive<'a, W> {
-    fn tagged_prev(&self) -> Option<Index> {
-        self.prev_node()
-            .map(|ni| self.graph.node_weight(ni).unwrap().retag(ni))
-    }
-
-    fn tagged_next(&self) -> Option<Index> {
-        self.next_node()
-            .map(|ni| self.graph.node_weight(ni).unwrap().retag(ni))
-    }
-}
-
 pub type FixedDot<'a> = GenericPrimitive<'a, FixedDotWeight>;
 
 impl<'a> FixedDot<'a> {
+    pub fn seg(&self) -> Option<FixedSegIndex> {
+        self.graph
+            .neighbors_undirected(self.index.node_index())
+            .filter(|ni| {
+                self.graph
+                    .edge_weight(
+                        self.graph
+                            .find_edge_undirected(self.index.node_index(), *ni)
+                            .unwrap()
+                            .0,
+                    )
+                    .unwrap()
+                    .is_adjacent()
+            })
+            .filter(|ni| self.graph.node_weight(*ni).unwrap().is_fixed_seg())
+            .map(|ni| FixedSegIndex::new(ni))
+            .next()
+    }
+
     pub fn bend(&self) -> Option<FixedBendIndex> {
         self.graph
             .neighbors_undirected(self.index.node_index())

src/router.rs

@@ -3,12 +3,11 @@ use petgraph::visit::EdgeRef;
 use spade::InsertionError;
 
 use crate::astar::{astar, AstarStrategy, PathTracker};
-use crate::graph::{DotIndex, Ends, FixedDotIndex, FixedDotWeight};
+use crate::graph::{DotIndex, FixedDotIndex};
 use crate::layout::Layout;
 
-use crate::math::Circle;
 use crate::mesh::{Mesh, MeshEdgeReference, VertexIndex};
-use crate::primitive::GetWeight;
+
 use crate::rules::Rules;
 use crate::tracer::{Trace, Tracer};
 
@@ -114,11 +113,11 @@ impl Router {
 
     pub fn reroute(
         &mut self,
-        from: FixedDotIndex,
+        _from: FixedDotIndex,
-        to: Point,
+        _to: Point,
-        observer: &mut impl RouterObserver,
+        _observer: &mut impl RouterObserver,
     ) -> Result<Mesh, InsertionError> {
-        let to_dot = if let Some(band) = self.layout.next_band(from) {
+        /*let to_dot = if let Some(band) = self.layout.next_band(from) {
             let to_dot = band.ends().1;
 
             self.layout.remove_interior(&band);
@@ -134,7 +133,8 @@ impl Router {
                 .unwrap() // TODO.
         };
 
-        self.enroute(from, to_dot, observer)
+        self.enroute(from, to_dot, observer)*/
+        Ok(Mesh::new())
     }
 
     /*pub fn squeeze_around_dot(

src/segbend.rs

@@ -1,11 +1,8 @@
 use petgraph::stable_graph::StableDiGraph;
 
 use crate::{
-    graph::{
+    graph::{Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior, Label, Weight},
-        BendIndex, DotIndex, Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior,
+    primitive::{FixedBend, FixedDot},
-        Label, SegIndex, Weight,
-    },
-    primitive::{FixedBend, FixedDot, TaggedPrevTaggedNext},
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -24,13 +21,9 @@ impl Segbend {
         dot: FixedDotIndex,
         graph: &StableDiGraph<Weight, Label, usize>,
     ) -> Option<Self> {
-        let bend = *FixedDot::new(dot, graph).tagged_prev()?.as_fixed_bend()?;
+        let bend = FixedDot::new(dot, graph).bend()?;
         let dot = FixedBend::new(bend, graph).prev().unwrap();
-        let seg = FixedDot::new(dot, graph)
+        let seg = FixedDot::new(dot, graph).seg().unwrap();
-            .tagged_prev()
-            .unwrap()
-            .into_fixed_seg()
-            .unwrap();
         Some(Self { bend, dot, seg })
     }
 
@@ -38,13 +31,9 @@ impl Segbend {
         dot: FixedDotIndex,
         graph: &StableDiGraph<Weight, Label, usize>,
     ) -> Option<Self> {
-        let bend = *FixedDot::new(dot, graph).tagged_next()?.as_fixed_bend()?;
+        let bend = FixedDot::new(dot, graph).bend()?;
         let dot = FixedBend::new(bend, graph).next().unwrap();
-        let seg = FixedDot::new(dot, graph)
+        let seg = FixedDot::new(dot, graph).seg().unwrap();
-            .tagged_next()
-            .unwrap()
-            .into_fixed_seg()
-            .unwrap();
         Some(Self { bend, dot, seg })
     }
 }

src/tracer.rs

@@ -6,7 +6,7 @@ use crate::{
     graph::{Ends, FixedBendIndex, FixedDotIndex},
     layout::Layout,
     mesh::{Mesh, VertexIndex},
-    primitive::{GetWeight, MakeShape},
+    primitive::GetWeight,
     rules::Rules,
 };
 
@@ -124,11 +124,11 @@ impl<'a> Tracer<'a> {
 
     fn is_under(
         &mut self,
-        head: Head,
+        _head: Head,
         around: FixedDotIndex,
-        layer: FixedBendIndex,
+        _layer: FixedBendIndex,
     ) -> Option<bool> {
-        let around_pos = self.layout.primitive(around).weight().circle.pos;
+        let _around_pos = self.layout.primitive(around).weight().circle.pos;
 
         /*if Some(layer) != self.layout.primitive(head.dot()).prev_bend() {
             Some(