Renamed the private graph iterators to attune for upcoming changes

src/models/append_graph.rs

@@ -23,12 +23,12 @@ struct IncidenceEntry {
     adjacent: Vertex,
 }
 
-struct VertexAdjacenceIterator<'a> {
+struct AdjacentVertexIterator<'a> {
     graph: &'a AppendGraph,
     incidence: Option<Incidence>,
 }
 
-impl<'a> Iterator for VertexAdjacenceIterator<'a> {
+impl<'a> Iterator for AdjacentVertexIterator<'a> {
     type Item = Vertex;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -113,7 +113,7 @@ impl GraphTopology for AppendGraph {
     }
 
     fn adjacent_vertices(&self, v: Self::Vertex) -> impl Iterator<Item = Self::Vertex> {
-        VertexAdjacenceIterator {
+        AdjacentVertexIterator {
             graph: self,
             incidence: self.vertices[v.0].first_incidence,
         }

src/models/graph.rs

@@ -23,50 +23,50 @@ pub struct IncidenceEntry {
     adjacent: VertexSlot,
 }
 
-struct VertexAdjacenceIterator<'a> {
+struct AdjacentVertexIterator<'a> {
     graph: &'a Graph,
     incidence: Option<IncidenceSlot>,
 }
 
-impl<'a> Iterator for VertexAdjacenceIterator<'a> {
+impl<'a> Iterator for AdjacentVertexIterator<'a> {
     type Item = Vertex;
 
     fn next(&mut self) -> Option<Self::Item> {
         // TODO: Benchmark storing full Index (one read, larger entries) vs. slot + get_idx() (two reads, smaller entries).
         let incidence = self.incidence?;
-        let index = self.graph.incidences.get_idx(incidence.0)?;
-        let entry = &self.graph.incidences[index];
+        let i = self.graph.incidences.get_idx(incidence.0).unwrap();
+        let entry = &self.graph.incidences[i];
         self.incidence = entry.next;
-        self.graph.vertices.get_idx(entry.adjacent.0)
+        Some(self.graph.vertices.get_idx(entry.adjacent.0).unwrap())
     }
 }
 
-struct VertexIncidenceIterator<'a> {
+struct IncidentEdgeIterator<'a> {
     graph: &'a Graph,
     incidence: Option<IncidenceSlot>,
 }
 
-impl<'a> Iterator for VertexIncidenceIterator<'a> {
+impl<'a> Iterator for IncidentEdgeIterator<'a> {
     type Item = Edge;
 
     fn next(&mut self) -> Option<Self::Item> {
         let current = self.incidence?;
-        let index = self.graph.incidences.get_idx(current.0)?;
-        self.incidence = self.graph.incidences[index].next;
-        Some(index)
+        let e = self.graph.incidences.get_idx(current.0).unwrap();
+        self.incidence = self.graph.incidences[e].next;
+        Some(e)
     }
 }
 
-struct VertexIncidenceCursor {
+struct IncidentEdgeCursor {
     incidence: Option<IncidenceSlot>,
 }
 
-impl VertexIncidenceCursor {
+impl IncidentEdgeCursor {
     fn next(&mut self, graph: &Graph) -> Option<Edge> {
         let current = self.incidence?;
-        let index = graph.incidences.get_idx(current.0)?;
-        self.incidence = graph.incidences[index].next;
-        Some(index)
+        let e = graph.incidences.get_idx(current.0).unwrap();
+        self.incidence = graph.incidences[e].next;
+        Some(e)
     }
 }
 
@@ -133,7 +133,7 @@ impl Graph {
         if first.0 == e.arr_idx() {
             vertex_header.first_incidence = next;
         } else {
-            let previous = VertexIncidenceIterator {
+            let previous = IncidentEdgeIterator {
                 graph: self,
                 incidence: self.vertices[source_vertex].first_incidence,
             }
@@ -192,7 +192,7 @@ impl GraphTopology for Graph {
     }
 
     fn adjacent_vertices(&self, v: Self::Vertex) -> impl Iterator<Item = Self::Vertex> {
-        VertexAdjacenceIterator {
+        AdjacentVertexIterator {
             graph: self,
             incidence: self.vertices[v].first_incidence,
         }
@@ -226,7 +226,7 @@ impl GraphTopologyDeletion for Graph {
             .vertices
             .remove(v)
             .expect("attempt to delete an invalid vertex");
-        let mut cursor = VertexIncidenceCursor {
+        let mut cursor = IncidentEdgeCursor {
             incidence: v_header.first_incidence,
         };
         while let Some(e) = cursor.next(self) {