src/graph.rs

@@ -12,4 +12,7 @@ pub trait Graph<V: Vertex, E: Edge> {
     // disconnect two nodes, and return the old edge
     // fn disconnect(vertex_1: &V, vertex_2: &V) -> E;
     fn disconnect(&mut self, edge: E::HANDLE);
+
+    // get the degree of a given vertex - possibly put this in a GraphUtil trait?
+    fn degree(vertex: V::HANDLE) -> usize;
 }

src/test.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::marker::PhantomData;
 
 use crate::{edge::Edge, graph::Graph, vertex::Vertex};
 
@@ -14,7 +14,6 @@ impl Edge for SimpleEdge {
 
 struct SimpleVertex {
     id: usize,
-    edges: HashSet<<SimpleEdge as Edge>::HANDLE>,
 }
 
 impl SimpleVertex {
@@ -25,124 +24,78 @@ impl SimpleVertex {
 
 impl Vertex for SimpleVertex {
     type HANDLE = usize;
-
-    fn degree(&self) -> usize {
-        return self.edges.len();
-    }
 }
 
 struct SimpleGraph {
-    vertices: HashMap<usize, SimpleVertex>,
+    vertices: Vec<SimpleVertex>,
-    edges: HashMap<usize, SimpleEdge>,
+    edges: Vec<SimpleEdge>,
 }
 
-impl SimpleGraph {
+impl SimpleGraph {}
-    pub fn new_vertex(&mut self) -> <SimpleVertex as Vertex>::HANDLE {
-        let id = self.vertices.len();
-        let v = SimpleVertex {
-            id: id.clone(),
-            edges: HashSet::new(),
-        };
-        self.vertices.insert(id, v);
-        id
-    }
-}
 
 impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
     fn connect(&mut self, vertex_1: usize, vertex_2: usize) -> usize {
         let id = self.edges.len();
-
+        self.edges.push(SimpleEdge {
-        // create the edge
+            id: id.clone(),
-        self.edges.insert(
+            v1: vertex_1,
-            id,
+            v2: vertex_2,
-            SimpleEdge {
+        });
-                id: id.clone(),
-                v1: vertex_1,
-                v2: vertex_2,
-            },
-        );
-
-        // add the edge handle to each vertex
-        if let Some(v) = self.vertices.get_mut(&vertex_1) {
-            v.edges.insert(id);
-        }
-        if let Some(v) = self.vertices.get_mut(&vertex_2) {
-            v.edges.insert(id);
-        }
-
         id
     }
 
     // NOTE: this should probably be a failable function... and use a hashmap
     fn disconnect(&mut self, edge: usize) {
-        // TODO: handle unhappy path
+        for i in (0..self.edges.len()) {
-        if let Some(e) = self.edges.remove(&edge) {
+            if self.edges[i].id == edge {
-            // remove the edge handle from each vertex
+                self.edges.remove(i);
-            if let Some(v) = self.vertices.get_mut(&e.v1) {
+                return;
-                v.edges.remove(&e.id);
-            }
-            if let Some(v) = self.vertices.get_mut(&e.v2) {
-                v.edges.remove(&e.id);
             }
         }
     }
+
+    fn degree(vertex: usize) -> usize {
+        todo!();
+    }
 }
 
 #[test]
-fn simple_connect() {
+fn it_works() {}
+
+#[test]
+fn test_connect() {
+    let v1 = SimpleVertex { id: 0 };
+    let v2 = SimpleVertex { id: 1 };
     let mut g = SimpleGraph {
-        vertices: HashMap::new(),
+        vertices: vec![v1, v2],
-        edges: HashMap::new(),
+        edges: Vec::new(),
     };
-    let h1 = g.new_vertex();
+    let _e = g.connect(0, 1);
-    let h2 = g.new_vertex();
-    assert_eq!(g.vertices.len(), 2);
-
-    let e = g.connect(h1, h2);
     assert_eq!(g.edges.len(), 1);
-
+    assert_eq!(g.edges[0].id, 0);
-    let e = g.edges.get(&e).unwrap();
+    assert_eq!(g.edges[0].v1, 0);
-    assert_eq!(e.id, 0);
+    assert_eq!(g.edges[0].v2, 1);
-    assert_eq!(e.v1, h1);
-    assert_eq!(e.v2, h2);
 }
 
 #[test]
-fn simple_disconnect() {
+fn test_disconnect() {
+    let v1 = SimpleVertex { id: 0 };
+    let v2 = SimpleVertex { id: 1 };
     let mut g = SimpleGraph {
-        vertices: HashMap::new(),
+        vertices: vec![v1, v2],
-        edges: HashMap::new(),
+        edges: Vec::new(),
     };
-    let h1 = g.new_vertex();
+    let e = g.connect(0, 1);
-    let h2 = g.new_vertex();
-    assert_eq!(g.vertices.len(), 2);
-
-    let e = g.connect(h1, h2);
     assert_eq!(g.edges.len(), 1);
+    assert_eq!(g.edges[0].id, 0);
+    assert_eq!(g.edges[0].v1, 0);
+    assert_eq!(g.edges[0].v2, 1);
 
-    let e = g.edges.get(&e).unwrap();
+    g.disconnect(e);
-    assert_eq!(e.id, 0);
-    assert_eq!(e.v1, h1);
-    assert_eq!(e.v2, h2);
-
-    g.disconnect(e.id);
     assert_eq!(g.edges.len(), 0);
 }
 
 #[test]
-fn simple_degree() {
+fn test_degree() {
-    let mut g = SimpleGraph {
+    todo!()
-        vertices: HashMap::new(),
-        edges: HashMap::new(),
-    };
-    let h1 = g.new_vertex();
-    let h2 = g.new_vertex();
-    let h3 = g.new_vertex();
-
-    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);
 }

src/vertex.rs

@@ -1,6 +1,3 @@
 pub trait Vertex {
     type HANDLE;
-
-    // get the degree of a given vertex - possibly put this in a GraphUtil trait?
-    fn degree(&self) -> usize;
 }