graph,layout,primitive: Rename "layers" to "rails"

By "layer" we should be referring to the PCB layers. A "rail" shall be
one in a spatial sequence of parallel and topologically linked tracks,
which together shall be called a "railing".

src/mesh.rs

@@ -34,7 +34,7 @@ pub enum VertexIndex {
 #[derive(Debug, Clone)]
 struct TriangulationWeight {
     vertex: VertexIndex,
-    layers: Vec<LooseBendIndex>,
+    rails: Vec<LooseBendIndex>,
     pos: Point,
 }
 
@@ -71,14 +71,14 @@ impl Mesh {
                 Index::FixedDot(fixed_dot) => {
                     self.triangulation.add_vertex(TriangulationWeight {
                         vertex: fixed_dot.into(),
-                        layers: vec![],
+                        rails: vec![],
                         pos: center,
                     })?;
                 }
                 Index::FixedBend(fixed_bend) => {
                     self.triangulation.add_vertex(TriangulationWeight {
                         vertex: fixed_bend.into(),
-                        layers: vec![],
+                        rails: vec![],
                         pos: center,
                     })?;
                 }
@@ -91,7 +91,7 @@ impl Mesh {
                 Index::LooseBend(loose_bend) => {
                     self.triangulation
                         .weight_mut(layout.primitive(loose_bend).core().into())
-                        .layers
+                        .rails
                         .push(loose_bend.into());
                 }
                 _ => (),
@@ -148,7 +148,7 @@ impl<'a> visit::IntoNeighbors for &'a Mesh {
             iter::once(neighbor).chain(
                 self.triangulation
                     .weight(neighbor)
-                    .layers
+                    .rails
                     .iter()
                     .map(|index| VertexIndex::from(*index)),
             )
@@ -164,7 +164,7 @@ fn edges(
     from_vertices.extend(
         triangulation
             .weight(edge.source())
-            .layers
+            .rails
             .iter()
             .map(|bend| VertexIndex::from(*bend)),
     );
@@ -173,7 +173,7 @@ fn edges(
     to_vertices.extend(
         triangulation
             .weight(edge.target())
-            .layers
+            .rails
             .iter()
             .map(|bend| VertexIndex::from(*bend)),
     );

src/primitive.rs

@@ -12,7 +12,7 @@ use crate::graph::{
 };
 use crate::math::{self, Circle};
 use crate::shape::{BendShape, DotShape, SegShape, Shape, ShapeTrait};
-use crate::traverser::OutwardLayerTraverser;
+use crate::traverser::OutwardRailTraverser;
 
 #[enum_dispatch]
 pub trait GetGraph {
@@ -50,14 +50,14 @@ pub trait GetOtherEnd<F: GetNodeIndex, T: GetNodeIndex + Into<F>>: GetEnds<F, T>
     }
 }
 
-pub trait TraverseOutward: GetFirstLayer {
-    fn traverse_outward(&self) -> OutwardLayerTraverser {
-        OutwardLayerTraverser::new(self.first_layer(), self.graph())
+pub trait TraverseOutward: GetFirstRail {
+    fn traverse_outward(&self) -> OutwardRailTraverser {
+        OutwardRailTraverser::new(self.first_rail(), self.graph())
     }
 }
 
-pub trait GetFirstLayer: GetGraph + GetNodeIndex {
-    fn first_layer(&self) -> Option<LooseBendIndex> {
+pub trait GetFirstRail: GetGraph + GetNodeIndex {
+    fn first_rail(&self) -> Option<LooseBendIndex> {
         self.graph()
             .neighbors_directed(self.node_index(), Incoming)
             .filter(|ni| self.graph().find_edge(self.node_index(), *ni).is_some())
@@ -240,7 +240,7 @@ impl<'a> MakeShape for FixedDot<'a> {
 }
 
 impl<'a> TraverseOutward for FixedDot<'a> {}
-impl<'a> GetFirstLayer for FixedDot<'a> {}
+impl<'a> GetFirstRail for FixedDot<'a> {}
 
 pub type LooseDot<'a> = GenericPrimitive<'a, LooseDotWeight>;
 impl_primitive!(LooseDot, LooseDotWeight);
@@ -406,7 +406,7 @@ impl<'a> GetEnds<FixedDotIndex, FixedDotIndex> for FixedBend<'a> {
 
 impl<'a> GetOtherEnd<FixedDotIndex, FixedDotIndex> for FixedBend<'a> {}
 impl<'a> TraverseOutward for FixedBend<'a> {}
-impl<'a> GetFirstLayer for FixedBend<'a> {}
+impl<'a> GetFirstRail for FixedBend<'a> {}
 impl<'a> GetCore for FixedBend<'a> {} // TODO: Fixed bends don't have cores actually.
                                       //impl<'a> GetInnerOuter for FixedBend<'a> {}
 
@@ -416,11 +416,11 @@ impl_primitive!(LooseBend, LooseBendWeight);
 impl<'a> LooseBend<'a> {
     fn inner_radius(&self) -> f64 {
         let mut r = 0.0;
-        let mut layer = LooseBendIndex::new(self.index.node_index());
+        let mut rail = LooseBendIndex::new(self.index.node_index());
 
-        while let Some(inner) = self.primitive(layer).inner() {
+        while let Some(inner) = self.primitive(rail).inner() {
             r += self.primitive(inner).width();
-            layer = inner;
+            rail = inner;
         }
 
         let core_circle = self

src/tracer.rs

@@ -5,7 +5,7 @@ use crate::{
     graph::{FixedDotIndex, LooseBendIndex},
     layout::Layout,
     mesh::{Mesh, VertexIndex},
-    primitive::{GetFirstLayer, GetInnerOuter},
+    primitive::{GetFirstRail, GetInnerOuter},
     rules::Rules,
 };
 
@@ -106,8 +106,8 @@ impl<'a> Tracer<'a> {
     ) -> Result<SegbendHead, ()> {
         let head = self.draw().segbend_around_dot(head, around.into(), width)?;
 
-        if let Some(first_layer) = self.layout.primitive(around).first_layer() {
-            self.layout.reattach_bend(first_layer, head.segbend.bend);
+        if let Some(first_rail) = self.layout.primitive(around).first_rail() {
+            self.layout.reattach_bend(first_rail, head.segbend.bend);
             self.update_outward(head.segbend.bend);
         }
 
@@ -134,11 +134,11 @@ impl<'a> Tracer<'a> {
     }
 
     fn update_outward(&mut self, bend: LooseBendIndex) {
-        let mut layer = bend;
+        let mut rail = bend;
 
-        while let Some(outer) = self.layout.primitive(layer).outer() {
+        while let Some(outer) = self.layout.primitive(rail).outer() {
             self.draw().update_bow(bend);
-            layer = outer;
+            rail = outer;
         }
     }
 

src/traverser.rs

@@ -5,27 +5,27 @@ use crate::{
     primitive::{GenericPrimitive, GetInnerOuter},
 };
 
-pub struct OutwardLayerTraverser<'a> {
-    layer: Option<LooseBendIndex>,
+pub struct OutwardRailTraverser<'a> {
+    rail: Option<LooseBendIndex>,
     graph: &'a StableDiGraph<Weight, Label, usize>,
 }
 
-impl<'a> OutwardLayerTraverser<'a> {
+impl<'a> OutwardRailTraverser<'a> {
     pub fn new(
-        layer: Option<LooseBendIndex>,
+        rail: Option<LooseBendIndex>,
         graph: &'a StableDiGraph<Weight, Label, usize>,
     ) -> Self {
-        Self { layer, graph }
+        Self { rail, graph }
     }
 }
 
-impl<'a> Iterator for OutwardLayerTraverser<'a> {
+impl<'a> Iterator for OutwardRailTraverser<'a> {
     type Item = LooseBendIndex;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.layer.map(|layer| {
-            self.layer = GenericPrimitive::new(layer, self.graph).outer();
-            layer
+        self.rail.map(|rail| {
+            self.rail = GenericPrimitive::new(rail, self.graph).outer();
+            rail
         })
     }
 }