layout: alias `Node` to not require generic parameters

src/bin/topola-egui/app.rs

@@ -10,7 +10,7 @@ use topola::{
     dsn::{design::DsnDesign, rules::DsnRules},
     geometry::{
         primitive::{BendShape, DotShape, PrimitiveShape, SegShape},
-        Node,
+        GenericNode,
     },
     layout::{zone::MakePolygon, Layout},
     math::Circle,
@@ -154,7 +154,11 @@ impl eframe::App for App {
                     for node in layout.drawing().layer_primitive_nodes(1) {
                         let shape = node.primitive(layout.drawing()).shape();
 
-                        let color = if self.overlay.selection().contains(&Node::Primitive(node)) {
+                        let color = if self
+                            .overlay
+                            .selection()
+                            .contains(&GenericNode::Primitive(node))
+                        {
                             egui::Color32::from_rgb(100, 100, 255)
                         } else {
                             egui::Color32::from_rgb(52, 52, 200)
@@ -172,7 +176,11 @@ impl eframe::App for App {
                     for node in layout.drawing().layer_primitive_nodes(0) {
                         let shape = node.primitive(layout.drawing()).shape();
 
-                        let color = if self.overlay.selection().contains(&Node::Primitive(node)) {
+                        let color = if self
+                            .overlay
+                            .selection()
+                            .contains(&GenericNode::Primitive(node))
+                        {
                             egui::Color32::from_rgb(255, 100, 100)
                         } else {
                             egui::Color32::from_rgb(200, 52, 52)

src/drawing/drawing.rs

@@ -29,7 +29,7 @@ use crate::drawing::{
 };
 use crate::geometry::compound::CompoundManagerTrait;
 use crate::geometry::with_rtree::BboxedIndex;
-use crate::geometry::Node;
+use crate::geometry::GenericNode;
 use crate::geometry::{
     primitive::{PrimitiveShape, PrimitiveShapeTrait},
     with_rtree::GeometryWithRtree,
@@ -639,7 +639,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
             .rtree()
             .iter()
             .filter_map(|wrapper| {
-                if let Node::Primitive(primitive_node) = wrapper.data {
+                if let GenericNode::Primitive(primitive_node) = wrapper.data {
                     Some(primitive_node)
                 } else {
                     None
@@ -655,7 +655,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
                 [f64::INFINITY, f64::INFINITY, layer as f64],
             ))
             .filter_map(|wrapper| {
-                if let Node::Primitive(primitive_node) = wrapper.data {
+                if let GenericNode::Primitive(primitive_node) = wrapper.data {
                     Some(primitive_node)
                 } else {
                     None
@@ -750,7 +750,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
             .rtree()
             .locate_in_envelope_intersecting(&limiting_shape.full_height_envelope_3d(0.0, 2))
             .filter_map(|wrapper| {
-                if let Node::Primitive(primitive_node) = wrapper.data {
+                if let GenericNode::Primitive(primitive_node) = wrapper.data {
                     Some(primitive_node)
                 } else {
                     None
@@ -785,7 +785,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
             .rtree()
             .locate_in_envelope_intersecting(&shape.full_height_envelope_3d(0.0, 2))
             .filter_map(|wrapper| {
-                if let Node::Primitive(primitive_node) = wrapper.data {
+                if let GenericNode::Primitive(primitive_node) = wrapper.data {
                     Some(primitive_node)
                 } else {
                     None
@@ -833,7 +833,7 @@ impl<CW: Copy, R: RulesTrait> Drawing<CW, R> {
 
     #[debug_ensures(self.geometry_with_rtree.graph().node_count() == old(self.geometry_with_rtree.graph().node_count()))]
     #[debug_ensures(self.geometry_with_rtree.graph().edge_count() == old(self.geometry_with_rtree.graph().edge_count()))]
-    pub fn rtree(&self) -> &RTree<BboxedIndex<Node<PrimitiveIndex, GenericIndex<CW>>>> {
+    pub fn rtree(&self) -> &RTree<BboxedIndex<GenericNode<PrimitiveIndex, GenericIndex<CW>>>> {
         self.geometry_with_rtree.rtree()
     }
 

src/drawing/primitive.rs

@@ -20,7 +20,7 @@ use crate::{
         },
         Drawing,
     },
-    geometry::Node,
+    geometry::GenericNode,
 };
 
 #[enum_dispatch]
@@ -186,7 +186,7 @@ impl<'a, W, CW: Copy, R: RulesTrait> GenericPrimitive<'a, W, CW, R> {
     }
 
     fn tagged_weight(&self) -> PrimitiveWeight {
-        if let Node::Primitive(weight) = *self
+        if let GenericNode::Primitive(weight) = *self
             .drawing
             .geometry()
             .graph()
@@ -262,9 +262,15 @@ impl<'a, CW: Copy, R: RulesTrait> FixedDot<'a, CW, R> {
                     .graph()
                     .node_weight(ni.node_index())
                     .unwrap();
-                if matches!(weight, Node::Primitive(PrimitiveWeight::LoneLooseSeg(..))) {
+                if matches!(
+                    weight,
+                    GenericNode::Primitive(PrimitiveWeight::LoneLooseSeg(..))
+                ) {
                     Some(LoneLooseSegIndex::new(ni.node_index()).into())
-                } else if matches!(weight, Node::Primitive(PrimitiveWeight::SeqLooseSeg(..))) {
+                } else if matches!(
+                    weight,
+                    GenericNode::Primitive(PrimitiveWeight::SeqLooseSeg(..))
+                ) {
                     Some(SeqLooseSegIndex::new(ni.node_index()).into())
                 } else {
                     None

src/geometry/geometry.rs

@@ -59,7 +59,7 @@ pub enum GeometryLabel {
 }
 
 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
-pub enum Node<P, C> {
+pub enum GenericNode<P, C> {
     Primitive(P),
     Compound(C),
 }
@@ -80,7 +80,7 @@ pub struct Geometry<
     SI: GetNodeIndex + Into<PI> + Copy,
     BI: GetNodeIndex + Into<PI> + Copy,
 > {
-    graph: StableDiGraph<Node<PW, CW>, GeometryLabel, usize>,
+    graph: StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize>,
     weight_marker: PhantomData<PW>,
     dot_weight_marker: PhantomData<DW>,
     seg_weight_marker: PhantomData<SW>,
@@ -120,7 +120,7 @@ impl<
     }
 
     pub fn add_dot<W: DotWeightTrait<PW>>(&mut self, weight: W) -> GenericIndex<W> {
-        GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())))
+        GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())))
     }
 
     pub fn add_seg<W: SegWeightTrait<PW>>(
@@ -129,7 +129,8 @@ impl<
         to: DI,
         weight: W,
     ) -> GenericIndex<W> {
-        let seg = GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())));
+        let seg =
+            GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
 
         self.graph
             .update_edge(from.node_index(), seg.node_index(), GeometryLabel::Joined);
@@ -146,7 +147,8 @@ impl<
         core: DI,
         weight: W,
     ) -> GenericIndex<W> {
-        let bend = GenericIndex::<W>::new(self.graph.add_node(Node::Primitive(weight.into())));
+        let bend =
+            GenericIndex::<W>::new(self.graph.add_node(GenericNode::Primitive(weight.into())));
 
         self.graph
             .update_edge(from.node_index(), bend.node_index(), GeometryLabel::Joined);
@@ -165,13 +167,15 @@ impl<
     pub fn move_dot(&mut self, dot: DI, to: Point) {
         let mut weight = self.dot_weight(dot);
         weight.set_pos(to);
-        *self.graph.node_weight_mut(dot.node_index()).unwrap() = Node::Primitive(weight.into());
+        *self.graph.node_weight_mut(dot.node_index()).unwrap() =
+            GenericNode::Primitive(weight.into());
     }
 
     pub fn shift_bend(&mut self, bend: BI, offset: f64) {
         let mut weight = self.bend_weight(bend);
         weight.set_offset(offset);
-        *self.graph.node_weight_mut(bend.node_index()).unwrap() = Node::Primitive(weight.into());
+        *self.graph.node_weight_mut(bend.node_index()).unwrap() =
+            GenericNode::Primitive(weight.into());
     }
 
     pub fn flip_bend(&mut self, bend: BI) {
@@ -267,7 +271,7 @@ impl<
     }
 
     fn primitive_weight(&self, index: NodeIndex<usize>) -> PW {
-        if let Node::Primitive(weight) = *self.graph.node_weight(index).unwrap() {
+        if let GenericNode::Primitive(weight) = *self.graph.node_weight(index).unwrap() {
             weight
         } else {
             unreachable!()
@@ -293,7 +297,9 @@ impl<
     }
 
     pub fn compound_weight(&self, compound: GenericIndex<CW>) -> CW {
-        if let Node::Compound(weight) = *self.graph.node_weight(compound.node_index()).unwrap() {
+        if let GenericNode::Compound(weight) =
+            *self.graph.node_weight(compound.node_index()).unwrap()
+        {
             weight
         } else {
             unreachable!()
@@ -468,7 +474,7 @@ impl<
             })
     }
 
-    pub fn graph(&self) -> &StableDiGraph<Node<PW, CW>, GeometryLabel, usize> {
+    pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize> {
         &self.graph
     }
 }
@@ -486,7 +492,7 @@ impl<
     > CompoundManagerTrait<CW, GenericIndex<CW>> for Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>
 {
     fn add_compound(&mut self, weight: CW) -> GenericIndex<CW> {
-        GenericIndex::<CW>::new(self.graph.add_node(Node::Compound(weight)))
+        GenericIndex::<CW>::new(self.graph.add_node(GenericNode::Compound(weight)))
     }
 
     fn remove_compound(&mut self, compound: GenericIndex<CW>) {

src/geometry/with_rtree.rs

@@ -10,7 +10,8 @@ use crate::{
     geometry::{
         compound::CompoundManagerTrait,
         primitive::{PrimitiveShape, PrimitiveShapeTrait},
-        BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel, GetWidth, Node, SegWeightTrait,
+        BendWeightTrait, DotWeightTrait, GenericNode, Geometry, GeometryLabel, GetWidth,
+        SegWeightTrait,
     },
     graph::{GenericIndex, GetNodeIndex},
 };
@@ -48,7 +49,7 @@ pub struct GeometryWithRtree<
     BI: GetNodeIndex + Into<PI> + Copy,
 > {
     geometry: Geometry<PW, DW, SW, BW, CW, PI, DI, SI, BI>,
-    rtree: RTree<BboxedIndex<Node<PI, GenericIndex<CW>>>>,
+    rtree: RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>>,
     layer_count: u64,
     weight_marker: PhantomData<PW>,
     dot_weight_marker: PhantomData<DW>,
@@ -101,7 +102,7 @@ impl<
                     .dot_shape(dot.into().try_into().unwrap_or_else(|_| unreachable!()))
                     .envelope_3d(0.0, weight.layer()),
             ),
-            Node::Primitive(dot.into()),
+            GenericNode::Primitive(dot.into()),
         ));
         dot
     }
@@ -122,7 +123,7 @@ impl<
                     .seg_shape(seg.into().try_into().unwrap_or_else(|_| unreachable!()))
                     .envelope_3d(0.0, weight.layer()),
             ),
-            Node::Primitive(seg.into()),
+            GenericNode::Primitive(seg.into()),
         ));
         seg
     }
@@ -144,7 +145,7 @@ impl<
                     .bend_shape(bend.into().try_into().unwrap_or_else(|_| unreachable!()))
                     .envelope_3d(0.0, weight.layer()),
             ),
-            Node::Primitive(bend.into()),
+            GenericNode::Primitive(bend.into()),
         ));
         bend
     }
@@ -264,7 +265,7 @@ impl<
         BI: GetNodeIndex + Into<PI> + Copy,
     > GeometryWithRtree<PW, DW, SW, BW, CW, PI, DI, SI, BI>
 {
-    fn make_bbox(&self, primitive: PI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
+    fn make_bbox(&self, primitive: PI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
         if let Ok(dot) = <PI as TryInto<DI>>::try_into(primitive) {
             self.make_dot_bbox(dot)
         } else if let Ok(seg) = <PI as TryInto<SI>>::try_into(primitive) {
@@ -276,50 +277,50 @@ impl<
         }
     }
 
-    fn make_dot_bbox(&self, dot: DI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
+    fn make_dot_bbox(&self, dot: DI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
         BboxedIndex::new(
             Bbox::new(
                 self.geometry
                     .dot_shape(dot)
                     .envelope_3d(0.0, self.layer(dot.into())),
             ),
-            Node::Primitive(dot.into()),
+            GenericNode::Primitive(dot.into()),
         )
     }
 
-    fn make_seg_bbox(&self, seg: SI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
+    fn make_seg_bbox(&self, seg: SI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
         BboxedIndex::new(
             Bbox::new(
                 self.geometry
                     .seg_shape(seg)
                     .envelope_3d(0.0, self.layer(seg.into())),
             ),
-            Node::Primitive(seg.into()),
+            GenericNode::Primitive(seg.into()),
         )
     }
 
-    fn make_bend_bbox(&self, bend: BI) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
+    fn make_bend_bbox(&self, bend: BI) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
         BboxedIndex::new(
             Bbox::new(
                 self.geometry
                     .bend_shape(bend)
                     .envelope_3d(0.0, self.layer(bend.into())),
             ),
-            Node::Primitive(bend.into()),
+            GenericNode::Primitive(bend.into()),
         )
     }
 
     fn make_compound_bbox(
         &self,
         compound: GenericIndex<CW>,
-    ) -> BboxedIndex<Node<PI, GenericIndex<CW>>> {
+    ) -> BboxedIndex<GenericNode<PI, GenericIndex<CW>>> {
         let mut aabb = AABB::<[f64; 3]>::new_empty();
 
         for member in self.geometry.compound_members(compound) {
             aabb.merge(&self.make_bbox(member).geom().aabb);
         }
 
-        BboxedIndex::new(Bbox::new(aabb), Node::Compound(compound))
+        BboxedIndex::new(Bbox::new(aabb), GenericNode::Compound(compound))
     }
 
     fn shape(&self, primitive: PI) -> PrimitiveShape {
@@ -351,25 +352,25 @@ impl<
     }
 
     // XXX: The type appears wrong? I don't think it should contain CW?
-    pub fn rtree(&self) -> &RTree<BboxedIndex<Node<PI, GenericIndex<CW>>>> {
+    pub fn rtree(&self) -> &RTree<BboxedIndex<GenericNode<PI, GenericIndex<CW>>>> {
         &self.rtree
     }
 
-    pub fn graph(&self) -> &StableDiGraph<Node<PW, CW>, GeometryLabel, usize> {
+    pub fn graph(&self) -> &StableDiGraph<GenericNode<PW, CW>, GeometryLabel, usize> {
         self.geometry.graph()
     }
 
     fn test_envelopes(&self) -> bool {
         !self.rtree.iter().any(|wrapper| {
             // TODO: Test envelopes of compounds too.
-            let Node::Primitive(primitive_node) = wrapper.data else {
+            let GenericNode::Primitive(primitive_node) = wrapper.data else {
                 return false;
             };
             let shape = self.shape(primitive_node);
             let layer = self.layer(primitive_node);
             let wrapper = BboxedIndex::new(
                 Bbox::new(shape.envelope_3d(0.0, layer)),
-                Node::Primitive(primitive_node),
+                GenericNode::Primitive(primitive_node),
             );
             !self
                 .rtree

src/layout/layout.rs

@@ -6,7 +6,7 @@ use crate::{
     drawing::{
         bend::LooseBendWeight,
         dot::{DotIndex, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
-        graph::{PrimitiveIndex, Retag},
+        graph::{PrimitiveIndex, PrimitiveWeight, Retag},
         rules::RulesTrait,
         seg::{
             FixedSegIndex, FixedSegWeight, LoneLooseSegIndex, LoneLooseSegWeight, SeqLooseSegIndex,
@@ -17,8 +17,8 @@ use crate::{
         Drawing, Infringement, LayoutException,
     },
     geometry::{
-        compound::CompoundManagerTrait, BendWeightTrait, DotWeightTrait, Geometry, GeometryLabel,
+        compound::CompoundManagerTrait, BendWeightTrait, DotWeightTrait, GenericNode, Geometry,
-        GetWidth, Node, SegWeightTrait,
+        GeometryLabel, GetWidth, SegWeightTrait,
     },
     graph::{GenericIndex, GetNodeIndex},
     layout::{
@@ -29,6 +29,8 @@ use crate::{
     },
 };
 
+pub type NodeIndex = GenericNode<PrimitiveIndex, GenericIndex<ZoneWeight>>;
+
 pub struct Layout<R: RulesTrait> {
     drawing: Drawing<ZoneWeight, R>, // Shouldn't be public, but is for now because `Draw` needs it.
     connectivity: StableDiGraph<ConnectivityWeight, ConnectivityLabel, usize>,
@@ -170,7 +172,7 @@ impl<R: RulesTrait> Layout<R> {
 
     pub fn zones(&self) -> impl Iterator<Item = ZoneIndex> + '_ {
         self.drawing.rtree().iter().filter_map(|wrapper| {
-            if let Node::Compound(zone) = wrapper.data {
+            if let NodeIndex::Compound(zone) = wrapper.data {
                 Some(match self.drawing.geometry().compound_weight(zone) {
                     ZoneWeight::Solid(..) => {
                         ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index()))
@@ -191,7 +193,7 @@ impl<R: RulesTrait> Layout<R> {
                 [f64::INFINITY, f64::INFINITY, layer as f64],
             ))
             .filter_map(|wrapper| {
-                if let Node::Compound(zone) = wrapper.data {
+                if let NodeIndex::Compound(zone) = wrapper.data {
                     Some(match self.drawing.geometry().compound_weight(zone) {
                         ZoneWeight::Solid(..) => {
                             ZoneIndex::Solid(SolidZoneIndex::new(zone.node_index()))

src/overlay/overlay.rs

@@ -9,13 +9,13 @@ use crate::{
         primitive::MakeShape,
         rules::RulesTrait,
     },
-    geometry::{shape::ShapeTrait, Node},
+    geometry::shape::ShapeTrait,
     graph::GenericIndex,
-    layout::{zone::ZoneWeight, Layout},
+    layout::{zone::ZoneWeight, Layout, NodeIndex},
 };
 
 pub struct Overlay {
-    selection: HashSet<Node<PrimitiveIndex, GenericIndex<ZoneWeight>>>,
+    selection: HashSet<NodeIndex>,
     active_layer: u64,
 }
 
@@ -38,10 +38,10 @@ impl Overlay {
             .collect();
 
         if let Some(geom) = geoms.iter().find(|&&geom| match geom.data {
-            Node::Primitive(primitive) => {
+            NodeIndex::Primitive(primitive) => {
                 primitive.primitive(layout.drawing()).layer() == self.active_layer
             }
-            Node::Compound(compound) => false,
+            NodeIndex::Compound(compound) => false,
         }) {
             if self.toggle_selection_if_contains_point(layout, geom.data, at) {
                 return;
@@ -58,11 +58,11 @@ impl Overlay {
     fn toggle_selection_if_contains_point<R: RulesTrait>(
         &mut self,
         layout: &Layout<R>,
-        node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>,
+        node: NodeIndex,
         p: Point,
     ) -> bool {
         match node {
-            Node::Primitive(primitive) => {
+            NodeIndex::Primitive(primitive) => {
                 if primitive
                     .primitive(layout.drawing())
                     .shape()
@@ -72,19 +72,19 @@ impl Overlay {
                     return true;
                 }
             }
-            Node::Compound(compound) => (), // TODO.
+            NodeIndex::Compound(compound) => (), // TODO.
         }
 
         false
     }
 
-    fn toggle_selection(&mut self, node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>) {
+    fn toggle_selection(&mut self, node: NodeIndex) {
         if !self.selection.insert(node) {
             self.selection.remove(&node);
         }
     }
 
-    pub fn selection(&self) -> &HashSet<Node<PrimitiveIndex, GenericIndex<ZoneWeight>>> {
+    pub fn selection(&self) -> &HashSet<NodeIndex> {
         &self.selection
     }
 }