primitive: Implement appropriate `GetEnds` for primitives

Earlier I put a common implementation as a placeholder, now replaced it
with a correct implementation.

src/band.rs

@@ -1,4 +1,4 @@
-use crate::graph::{Ends, FixedDotIndex, Index, Interior};
+use crate::graph::{FixedDotIndex, GetEnds, Index, Interior};
 
 pub struct Band {
     from: FixedDotIndex,
@@ -61,7 +61,7 @@ impl Interior<Index> for Band {
     }
 }
 
-impl Ends<FixedDotIndex, FixedDotIndex> for Band {
+impl GetEnds<FixedDotIndex, FixedDotIndex> for Band {
     fn ends(&self) -> (FixedDotIndex, FixedDotIndex) {
         (self.from, self.to)
     }

src/bow.rs

@@ -1,7 +1,7 @@
 use petgraph::stable_graph::StableDiGraph;
 
 use crate::graph::{
-    Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior, Label, Weight,
+    FixedBendIndex, FixedDotIndex, FixedSegIndex, GetEnds, Index, Interior, Label, Weight,
 };
 use crate::primitive::{FixedBend, FixedDot, FixedSeg};
 
@@ -52,7 +52,7 @@ impl Interior<Index> for Bow {
     }
 }
 
-impl Ends<FixedDotIndex, FixedDotIndex> for Bow {
+impl GetEnds<FixedDotIndex, FixedDotIndex> for Bow {
     fn ends(&self) -> (FixedDotIndex, FixedDotIndex) {
         (self.seg1_dot1, self.seg2_dot2)
     }

src/draw.rs

@@ -4,8 +4,8 @@ use geo::{EuclideanLength, Point};
 
 use crate::{
     graph::{
-        DotIndex, Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight,
+        BendIndex, DotIndex, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight,
-        FixedSegIndex, FixedSegWeight, Index,
+        FixedSegIndex, FixedSegWeight, GetEnds, Index, LooseBendWeight,
     },
     guide::Guide,
     layout::Layout,
@@ -156,7 +156,7 @@ impl<'a> Draw<'a> {
     pub fn segbend_around_bend(
         &mut self,
         head: Head,
-        around: FixedBendIndex,
+        around: BendIndex,
         width: f64,
     ) -> Result<SegbendHead, ()> {
         let mut tangents = self.guide(&Default::default()).head_around_bend_segments(

src/graph.rs

@@ -12,7 +12,7 @@ pub trait Interior<T> {
     fn interior(&self) -> Vec<T>;
 }
 
-pub trait Ends<Start, Stop> {
+pub trait GetEnds<Start, Stop> {
     fn ends(&self) -> (Start, Stop);
 }
 

src/primitive.rs

@@ -5,10 +5,10 @@ use petgraph::stable_graph::{NodeIndex, StableDiGraph};
 use petgraph::Direction::{Incoming, Outgoing};
 
 use crate::graph::{
-    Ends, FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegIndex,
+    FixedBendIndex, FixedBendWeight, FixedDotIndex, FixedDotWeight, FixedSegIndex, FixedSegWeight,
-    FixedSegWeight, FullyLooseSegWeight, GenericIndex, GetNet, GetNodeIndex, HalfLooseSegWeight,
+    FullyLooseSegWeight, GenericIndex, GetEnds, GetNet, GetNodeIndex, HalfLooseSegWeight, Index,
-    Index, Interior, Label, LooseBendIndex, LooseBendWeight, LooseDotWeight, MakePrimitive, Retag,
+    Interior, Label, LooseBendIndex, LooseBendWeight, LooseDotIndex, LooseDotWeight, MakePrimitive,
-    Weight,
+    Retag, Weight,
 };
 use crate::math::{self, Circle};
 use crate::shape::{BendShape, DotShape, SegShape, Shape, ShapeTrait};
@@ -79,32 +79,12 @@ impl<'a, W> GenericPrimitive<'a, W> {
             .next()
     }
 
-    pub fn tagged_index(&self) -> Index {
+    fn tagged_weight(&self) -> Weight {
-        self.graph
-            .node_weight(self.index.node_index())
-            .unwrap()
-            .retag(self.index.node_index())
-    }
-
-    pub fn tagged_weight(&self) -> Weight {
         *self.graph.node_weight(self.index.node_index()).unwrap()
     }
 
-    fn primitive<WW>(&self, index: GenericIndex<WW>) -> GenericPrimitive<WW> {
+    fn adjacents(&self) -> Vec<NodeIndex<usize>> {
-        GenericPrimitive::new(index, &self.graph)
+        self.graph
-    }
-}
-
-impl<'a, W> Interior<Index> for GenericPrimitive<'a, W> {
-    fn interior(&self) -> Vec<Index> {
-        vec![self.tagged_index()]
-    }
-}
-
-impl<'a, W> Ends<FixedDotIndex, FixedDotIndex> for GenericPrimitive<'a, W> {
-    fn ends(&self) -> (FixedDotIndex, FixedDotIndex) {
-        let v = self
-            .graph
             .neighbors_undirected(self.index.node_index())
             .filter(|ni| {
                 self.graph
@@ -117,10 +97,17 @@ impl<'a, W> Ends<FixedDotIndex, FixedDotIndex> for GenericPrimitive<'a, W> {
                     .unwrap()
                     .is_adjacent()
             })
-            .filter(|ni| self.graph.node_weight(*ni).unwrap().is_fixed_dot())
+            .collect()
-            .map(|ni| FixedDotIndex::new(ni))
+    }
-            .collect::<Vec<_>>();
+
-        (v[0], v[1])
+    fn primitive<WW>(&self, index: GenericIndex<WW>) -> GenericPrimitive<WW> {
+        GenericPrimitive::new(index, &self.graph)
+    }
+}
+
+impl<'a, W> Interior<Index> for GenericPrimitive<'a, W> {
+    fn interior(&self) -> Vec<Index> {
+        vec![self.tagged_weight().retag(self.index.node_index())]
     }
 }
 
@@ -259,6 +246,13 @@ impl<'a> MakeShape for FixedSeg<'a> {
     }
 }
 
+impl<'a> GetEnds<FixedDotIndex, FixedDotIndex> for FixedSeg<'a> {
+    fn ends(&self) -> (FixedDotIndex, FixedDotIndex) {
+        let v = self.adjacents();
+        (FixedDotIndex::new(v[0]), FixedDotIndex::new(v[1]))
+    }
+}
+
 pub type HalfLooseSeg<'a> = GenericPrimitive<'a, HalfLooseSegWeight>;
 
 impl<'a> GetWeight<HalfLooseSegWeight> for HalfLooseSeg<'a> {
@@ -278,6 +272,13 @@ impl<'a> MakeShape for HalfLooseSeg<'a> {
     }
 }
 
+impl<'a> GetEnds<FixedDotIndex, LooseDotIndex> for HalfLooseSeg<'a> {
+    fn ends(&self) -> (FixedDotIndex, LooseDotIndex) {
+        let v = self.adjacents();
+        (FixedDotIndex::new(v[0]), LooseDotIndex::new(v[1]))
+    }
+}
+
 pub type FullyLooseSeg<'a> = GenericPrimitive<'a, FullyLooseSegWeight>;
 
 impl<'a> GetWeight<FullyLooseSegWeight> for FullyLooseSeg<'a> {
@@ -297,6 +298,13 @@ impl<'a> MakeShape for FullyLooseSeg<'a> {
     }
 }
 
+impl<'a> GetEnds<LooseDotIndex, LooseDotIndex> for FullyLooseSeg<'a> {
+    fn ends(&self) -> (LooseDotIndex, LooseDotIndex) {
+        let v = self.adjacents();
+        (LooseDotIndex::new(v[0]), LooseDotIndex::new(v[1]))
+    }
+}
+
 pub type FixedBend<'a> = GenericPrimitive<'a, FixedBendWeight>;
 
 impl<'a> FixedBend<'a> {
@@ -399,6 +407,13 @@ impl<'a> MakeShape for FixedBend<'a> {
     }
 }
 
+impl<'a> GetEnds<FixedDotIndex, FixedDotIndex> for FixedBend<'a> {
+    fn ends(&self) -> (FixedDotIndex, FixedDotIndex) {
+        let v = self.adjacents();
+        (FixedDotIndex::new(v[0]), FixedDotIndex::new(v[1]))
+    }
+}
+
 pub type LooseBend<'a> = GenericPrimitive<'a, LooseBendWeight>;
 
 impl<'a> LooseBend<'a> {
@@ -463,3 +478,10 @@ impl<'a> MakeShape for LooseBend<'a> {
         Shape::Bend(bend_shape)
     }
 }
+
+impl<'a> GetEnds<LooseDotIndex, LooseDotIndex> for LooseBend<'a> {
+    fn ends(&self) -> (LooseDotIndex, LooseDotIndex) {
+        let v = self.adjacents();
+        (LooseDotIndex::new(v[0]), LooseDotIndex::new(v[1]))
+    }
+}

src/segbend.rs

@@ -1,7 +1,9 @@
 use petgraph::stable_graph::StableDiGraph;
 
 use crate::{
-    graph::{Ends, FixedBendIndex, FixedDotIndex, FixedSegIndex, Index, Interior, Label, Weight},
+    graph::{
+        FixedBendIndex, FixedDotIndex, FixedSegIndex, GetEnds, Index, Interior, Label, Weight,
+    },
     primitive::{FixedBend, FixedDot},
 };
 
@@ -30,7 +32,7 @@ impl Interior<Index> for Segbend {
     }
 }
 
-impl Ends<FixedSegIndex, FixedBendIndex> for Segbend {
+impl GetEnds<FixedSegIndex, FixedBendIndex> for Segbend {
     fn ends(&self) -> (FixedSegIndex, FixedBendIndex) {
         (self.seg, self.bend)
     }

src/tracer.rs

@@ -3,7 +3,7 @@ use contracts::debug_ensures;
 use crate::{
     bow::Bow,
     draw::{BareHead, Draw, Head, HeadTrait, SegbendHead},
-    graph::{Ends, FixedBendIndex, FixedDotIndex},
+    graph::{FixedBendIndex, FixedDotIndex, GetEnds},
     layout::Layout,
     mesh::{Mesh, VertexIndex},
     primitive::GetWeight,
@@ -115,7 +115,7 @@ impl<'a> Tracer<'a> {
                     layer = outer;
                 }
 
-                return self.draw().segbend_around_bend(head, layer, width);
+                return self.draw().segbend_around_bend(head, layer.into(), width);
             }
         }
 
@@ -169,7 +169,7 @@ impl<'a> Tracer<'a> {
         let outer = self.layout.primitive(around).outer().unwrap();
         let head = self
             .draw()
-            .segbend_around_bend(Head::from(head), around, width)?;
+            .segbend_around_bend(Head::from(head), around.into(), width)?;
         self.layout.reattach_bend(outer, head.segbend.bend);
 
         self.redraw_outward(outer)?;
@@ -202,7 +202,7 @@ impl<'a> Tracer<'a> {
             let width = 5.0;
 
             let segbend_head = if let Some(inner) = maybe_inner {
-                self.draw().segbend_around_bend(head, inner, width)?
+                self.draw().segbend_around_bend(head, inner.into(), width)?
             } else {
                 self.draw().segbend_around_dot(head, core.into(), width)?
             };