refactor vertex -> node

src/graph.rs

@@ -1,13 +1,13 @@
 use crate::edge::Edge;
-use crate::vertex::Vertex;
+use crate::node::Node;
 
 /// operations you might want to do on a graph or on nodes in a graph
-pub trait Graph<V: Vertex, E: Edge> {
+pub trait Graph<N: Node, E: Edge> {
     // Connect two nodes, and return the edge
     // TODO: figure out a way to modify self? is that even needed?
     // same for `disconnect()`
     // fn connect(vertex_1: &V, vertex_2: &V) -> E;
-    fn connect(&mut self, vertex_1: V::HANDLE, vertex_2: V::HANDLE) -> E::HANDLE;
+    fn connect(&mut self, node_1: N::HANDLE, node_2: N::HANDLE) -> E::HANDLE;
 
     // disconnect two nodes, and return the old edge
     // fn disconnect(vertex_1: &V, vertex_2: &V) -> E;

src/lib.rs

@@ -1,6 +1,6 @@
 mod edge;
 mod graph;
-mod vertex;
+mod node;
 
 #[cfg(test)]
 mod test;

src/node.rs

@@ -1,4 +1,4 @@
-pub trait Vertex {
+pub trait Node {
     type HANDLE;
 
     // get the degree of a given vertex - possibly put this in a GraphUtil trait?

src/test.rs

@@ -1,29 +1,29 @@
 use std::collections::{HashMap, HashSet};
 
-use crate::{edge::Edge, graph::Graph, vertex::Vertex};
+use crate::{edge::Edge, graph::Graph, node::Node};
 
 struct SimpleEdge {
     id: usize,
-    v1: usize,
-    v2: usize,
+    n1: usize,
+    n2: usize,
 }
 
 impl Edge for SimpleEdge {
     type HANDLE = usize;
 }
 
-struct SimpleVertex {
+struct SimpleNode {
     id: usize,
     edges: HashSet<<SimpleEdge as Edge>::HANDLE>,
 }
 
-impl SimpleVertex {
+impl SimpleNode {
     pub fn get_id(&self) -> usize {
         self.id.clone()
     }
 }
 
-impl Vertex for SimpleVertex {
+impl Node for SimpleNode {
     type HANDLE = usize;
 
     fn degree(&self) -> usize {
@@ -32,24 +32,24 @@ impl Vertex for SimpleVertex {
 }
 
 struct SimpleGraph {
-    vertices: HashMap<usize, SimpleVertex>,
+    nodes: HashMap<usize, SimpleNode>,
     edges: HashMap<usize, SimpleEdge>,
 }
 
 impl SimpleGraph {
-    pub fn new_vertex(&mut self) -> <SimpleVertex as Vertex>::HANDLE {
-        let id = self.vertices.len();
-        let v = SimpleVertex {
+    pub fn new_node(&mut self) -> <SimpleNode as Node>::HANDLE {
+        let id = self.nodes.len();
+        let v = SimpleNode {
             id: id.clone(),
             edges: HashSet::new(),
         };
-        self.vertices.insert(id, v);
+        self.nodes.insert(id, v);
         id
     }
 }
 
-impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
-    fn connect(&mut self, vertex_1: usize, vertex_2: usize) -> usize {
+impl<'a> Graph<SimpleNode, SimpleEdge> for SimpleGraph {
+    fn connect(&mut self, node_1: usize, node_2: usize) -> usize {
         let id = self.edges.len();
 
         // create the edge
@@ -57,16 +57,16 @@ impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
             id,
             SimpleEdge {
                 id: id.clone(),
-                v1: vertex_1,
-                v2: vertex_2,
+                n1: node_1,
+                n2: node_2,
             },
         );
 
         // add the edge handle to each vertex
-        if let Some(v) = self.vertices.get_mut(&vertex_1) {
+        if let Some(v) = self.nodes.get_mut(&node_1) {
             v.edges.insert(id);
         }
-        if let Some(v) = self.vertices.get_mut(&vertex_2) {
+        if let Some(v) = self.nodes.get_mut(&node_2) {
             v.edges.insert(id);
         }
 
@@ -78,10 +78,10 @@ impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
         // TODO: handle unhappy path
         if let Some(e) = self.edges.remove(&edge) {
             // remove the edge handle from each vertex
-            if let Some(v) = self.vertices.get_mut(&e.v1) {
+            if let Some(v) = self.nodes.get_mut(&e.n1) {
                 v.edges.remove(&e.id);
             }
-            if let Some(v) = self.vertices.get_mut(&e.v2) {
+            if let Some(v) = self.nodes.get_mut(&e.n2) {
                 v.edges.remove(&e.id);
             }
         }
@@ -91,39 +91,39 @@ impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
 #[test]
 fn simple_connect() {
     let mut g = SimpleGraph {
-        vertices: HashMap::new(),
+        nodes: HashMap::new(),
         edges: HashMap::new(),
     };
-    let h1 = g.new_vertex();
-    let h2 = g.new_vertex();
-    assert_eq!(g.vertices.len(), 2);
+    let h1 = g.new_node();
+    let h2 = g.new_node();
+    assert_eq!(g.nodes.len(), 2);
 
     let e = g.connect(h1, h2);
     assert_eq!(g.edges.len(), 1);
 
     let e = g.edges.get(&e).unwrap();
     assert_eq!(e.id, 0);
-    assert_eq!(e.v1, h1);
-    assert_eq!(e.v2, h2);
+    assert_eq!(e.n1, h1);
+    assert_eq!(e.n2, h2);
 }
 
 #[test]
 fn simple_disconnect() {
     let mut g = SimpleGraph {
-        vertices: HashMap::new(),
+        nodes: HashMap::new(),
         edges: HashMap::new(),
     };
-    let h1 = g.new_vertex();
-    let h2 = g.new_vertex();
-    assert_eq!(g.vertices.len(), 2);
+    let h1 = g.new_node();
+    let h2 = g.new_node();
+    assert_eq!(g.nodes.len(), 2);
 
     let e = g.connect(h1, h2);
     assert_eq!(g.edges.len(), 1);
 
     let e = g.edges.get(&e).unwrap();
     assert_eq!(e.id, 0);
-    assert_eq!(e.v1, h1);
-    assert_eq!(e.v2, h2);
+    assert_eq!(e.n1, h1);
+    assert_eq!(e.n2, h2);
 
     g.disconnect(e.id);
     assert_eq!(g.edges.len(), 0);
@@ -132,17 +132,17 @@ fn simple_disconnect() {
 #[test]
 fn simple_degree() {
     let mut g = SimpleGraph {
-        vertices: HashMap::new(),
+        nodes: HashMap::new(),
         edges: HashMap::new(),
     };
-    let h1 = g.new_vertex();
-    let h2 = g.new_vertex();
-    let h3 = g.new_vertex();
+    let h1 = g.new_node();
+    let h2 = g.new_node();
+    let h3 = g.new_node();
 
     let e1 = g.connect(h1, h2);
     let e2 = g.connect(h1, h3);
 
-    assert_eq!(g.vertices.get(&h1).unwrap().degree(), 2);
-    assert_eq!(g.vertices.get(&h2).unwrap().degree(), 1);
-    assert_eq!(g.vertices.get(&h3).unwrap().degree(), 1);
+    assert_eq!(g.nodes.get(&h1).unwrap().degree(), 2);
+    assert_eq!(g.nodes.get(&h2).unwrap().degree(), 1);
+    assert_eq!(g.nodes.get(&h3).unwrap().degree(), 1);
 }