add SimpleVertex SimpleEdge SimpleGraph plus connection test

src/graph.rs

@@ -6,11 +6,13 @@ pub trait Graph<V: Vertex, 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(vertex_1: &V, vertex_2: &V) -> E;
+    fn connect(&mut self, vertex_1: V::HANDLE, vertex_2: V::HANDLE);
 
     // disconnect two nodes, and return the old edge
-    fn disconnect(vertex_1: &V, vertex_2: &V) -> E;
+    // fn disconnect(vertex_1: &V, vertex_2: &V) -> E;
+    fn disconnect(&mut self, vertex_1: V::HANDLE, vertex_2: V::HANDLE);
 
     // get the degree of a given vertex - possibly put this in a GraphUtil trait?
-    fn degree(vertex: V) -> usize;
+    fn degree(vertex: V::HANDLE) -> usize;
 }

src/test.rs

@@ -2,44 +2,49 @@ use std::marker::PhantomData;
 
 use crate::{edge::Edge, graph::Graph, vertex::Vertex};
 
-struct TestEdge<'a> {
-    v1: &'a TestVertex<'a>,
-    v2: &'a TestVertex<'a>,
+struct SimpleEdge {
+    id: usize,
+    v1: usize,
+    v2: usize,
 }
 
-impl<'a> Edge for TestEdge<'a> {}
+impl Edge for SimpleEdge {}
 
-struct TestVertex<'a> {
-    _phantom: PhantomData<&'a Self>,
+struct SimpleVertex {
+    id: usize,
 }
 
-impl<'a> Vertex for TestVertex<'a> {}
-
-struct TestGraph<'a> {
-    vertices: Vec<TestVertex<'a>>,
-    edges: Vec<TestEdge<'a>>,
-}
-
-impl<'a> TestGraph<'a> {
-    pub fn get_vertex(&self, index: usize) -> &TestVertex {
-        assert!(index < self.vertices.len());
-        &self.vertices[index]
+impl SimpleVertex {
+    pub fn get_id(&self) -> usize {
+        self.id.clone()
     }
 }
 
-impl<'a> Graph<TestVertex<'a>, TestEdge<'a>> for TestGraph<'a> {
-    fn connect(vertex_1: &TestVertex<'a>, vertex_2: &TestVertex<'a>) -> TestEdge<'a> {
-        TestEdge {
+impl Vertex for SimpleVertex {
+    type HANDLE = usize;
+}
+
+struct SimpleGraph {
+    vertices: Vec<SimpleVertex>,
+    edges: Vec<SimpleEdge>,
+}
+
+impl SimpleGraph {}
+
+impl<'a> Graph<SimpleVertex, SimpleEdge> for SimpleGraph {
+    fn connect(&mut self, vertex_1: usize, vertex_2: usize) {
+        self.edges.push(SimpleEdge {
+            id: self.edges.len(),
             v1: vertex_1,
             v2: vertex_2,
-        }
+        });
     }
 
-    fn disconnect(vertex_1: &TestVertex, vertex_2: &TestVertex) -> TestEdge<'a> {
+    fn disconnect(&mut self, vertex_1: usize, vertex_2: usize) {
         todo!();
     }
 
-    fn degree(vertex: TestVertex) -> usize {
+    fn degree(vertex: usize) -> usize {
         todo!();
     }
 }
@@ -49,20 +54,17 @@ fn it_works() {}
 
 #[test]
 fn test_connect() {
-    let v1 = TestVertex {};
-    let v2 = TestVertex {};
-    let mut g = TestGraph {
+    let v1 = SimpleVertex { id: 0 };
+    let v2 = SimpleVertex { id: 1 };
+    let mut g = SimpleGraph {
         vertices: vec![v1, v2],
         edges: Vec::new(),
     };
-
-    let v1 = g.get_vertex(0);
-    let v2 = g.get_vertex(1);
-    // TODO: because g is immutable borrowed above, the trait can't have a &mut self here, which leads to this
-    // not so great syntax. but maybe that's OK because since this is a trait library, we don't care about the
-    // overall implementation, and the graph class might not store the edge... but it does still feel like
-    // the graph has changed... but idk.
-    let e: TestEdge = TestGraph::connect(v1, v2);
+    g.connect(0, 1);
+    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);
 }
 
 #[test]

src/vertex.rs

@@ -1 +1,3 @@
-pub trait Vertex {}
+pub trait Vertex {
+    type HANDLE;
+}