Merge pull request #44 from purpleprotocol/dijkstra_api

Added Graph::dijkstra() api

Author: octavonce

README.md

@@ -38,7 +38,7 @@ assert_eq!(graph.edge_count(), 0);
 In `Cargo.toml`:
 ```toml
 [dependencies]
-graphlib = {version = "*", features = ["no_std"]}
+graphlib = { version = "*", features = ["no_std"] }
 ```
 
 ### Contributing

src/graph.rs

@@ -1,7 +1,7 @@
 // Copyright 2019 Octavian Oncescu
 
 use crate::edge::Edge;
-use crate::iterators::{Bfs, Dfs, Topo, VertexIter};
+use crate::iterators::*;
 use crate::vertex_id::VertexId;
 use hashbrown::{HashMap, HashSet};
 
@@ -1209,6 +1209,52 @@ impl<T> Graph<T> {
         Topo::new(self)
     }
 
+    /// Returns an iterator over the shortest path from the source
+    /// vertex to the destination vertex. The iterator will yield
+    /// `None` if there is no such path or the provided vertex ids
+    /// do not belong to any vertices in the graph.
+    /// ## Example
+    /// ```rust
+    /// #[macro_use] extern crate graphlib;
+    /// use graphlib::Graph;
+    /// use std::collections::HashSet;
+    ///
+    /// let mut graph: Graph<usize> = Graph::new();
+    ///
+    /// let v1 = graph.add_vertex(1);
+    /// let v2 = graph.add_vertex(2);
+    /// let v3 = graph.add_vertex(3);
+    /// let v4 = graph.add_vertex(4);
+    /// let v5 = graph.add_vertex(5);
+    /// let v6 = graph.add_vertex(6);
+    ///
+    /// graph.add_edge(&v1, &v2).unwrap();
+    /// graph.add_edge(&v2, &v3).unwrap();
+    /// graph.add_edge(&v3, &v4).unwrap();
+    /// graph.add_edge(&v3, &v5).unwrap();
+    /// graph.add_edge(&v5, &v6).unwrap();
+    /// graph.add_edge(&v6, &v4).unwrap();
+    ///
+    /// let mut dijkstra = graph.dijkstra(&v1, &v4);
+    ///
+    /// assert_eq!(dijkstra.next(), Some(&v1));
+    /// assert_eq!(dijkstra.next(), Some(&v2));
+    /// assert_eq!(dijkstra.next(), Some(&v3));
+    /// assert_eq!(dijkstra.next(), Some(&v4));
+    /// assert_eq!(dijkstra.next(), None);
+    /// ```
+    pub fn dijkstra<'a>(&'a self, src: &'a VertexId, dest: &'a VertexId) -> VertexIter<'a> {
+        if let Some(dijkstra) = Dijkstra::new(&self, src).ok() {
+            if let Some(iter) = dijkstra.get_path_to(dest).ok() {
+                iter
+            } else {
+                VertexIter(Box::new(iter::empty()))
+            }
+        } else {
+            VertexIter(Box::new(iter::empty()))
+        }
+    }
+
     #[cfg(feature = "dot")]
     /// Creates a file with the dot representation of the graph.
     /// This method requires the `dot` feature.

src/iterators/dijkstra.rs

@@ -2,18 +2,19 @@
 
 use crate::graph::{Graph, GraphErr};
 use crate::iterators::vertices::VertexIter;
+use crate::iterators::owning_iterator::OwningIterator;
 use crate::vertex_id::VertexId;
 
 use hashbrown::HashMap;
 use hashbrown::HashSet;
 
 #[cfg(not(feature = "no_std"))]
-use std::{cmp::Ordering, collections::BinaryHeap, f32, fmt::Debug, iter};
+use std::{cmp::Ordering, collections::{BinaryHeap, VecDeque}, f32, fmt::Debug, iter};
 
 #[cfg(feature = "no_std")]
 extern crate alloc;
 #[cfg(feature = "no_std")]
-use alloc::collections::binary_heap::BinaryHeap;
+use alloc::collections::binary_heap::{BinaryHeap, VecDeque};
 
 #[cfg(feature = "no_std")]
 use core::{cmp::Ordering, f32, fmt::Debug, iter};
@@ -38,12 +39,12 @@ impl Ord for VertexMeta {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 /// Dijkstra Single-source Shortest Path Iterator
 pub struct Dijkstra<'a, T> {
     source: &'a VertexId,
     iterable: &'a Graph<T>,
-    iterator: Vec<VertexId>,
+    iterator: VecDeque<VertexId>,
     distances: HashMap<VertexId, f32>,
     previous: HashMap<VertexId, Option<VertexId>>,
 }
@@ -65,7 +66,7 @@ impl<'a, T> Dijkstra<'a, T> {
         let mut instance = Dijkstra {
             source: src,
             iterable: graph,
-            iterator: Vec::with_capacity(graph.vertex_count()),
+            iterator: VecDeque::with_capacity(graph.vertex_count()),
             distances: HashMap::with_capacity(graph.vertex_count()),
             previous: HashMap::with_capacity(graph.vertex_count()),
         };
@@ -88,25 +89,25 @@ impl<'a, T> Dijkstra<'a, T> {
         Ok(())
     }
 
-    pub fn get_path_to(&mut self, vert: &'a VertexId) -> Result<VertexIter, GraphErr> {
+    pub fn get_path_to(mut self, vert: &'a VertexId) -> Result<VertexIter, GraphErr> {
         if self.iterable.fetch(vert).is_none() {
             return Err(GraphErr::NoSuchVertex);
         }
 
         if self.previous.contains_key(vert) {
-            let mut curr_vert = Some(vert);
+            let mut cur_vert = Some(vert);
             self.iterator.clear();
 
-            while curr_vert.is_some() {
-                self.iterator.push(*curr_vert.unwrap());
+            while cur_vert.is_some() {
+                self.iterator.push_front(*cur_vert.unwrap());
 
-                match self.previous.get(curr_vert.unwrap()) {
-                    Some(v) => curr_vert = v.as_ref(),
-                    None => curr_vert = None,
+                match self.previous.get(cur_vert.unwrap()) {
+                    Some(v) => cur_vert = v.as_ref(),
+                    None => cur_vert = None,
                 }
             }
 
-            return Ok(VertexIter(Box::new(self.iterator.iter())));
+            return Ok(VertexIter(Box::new(OwningIterator::new(self.iterator))));
         }
 
         Ok(VertexIter(Box::new(iter::empty())))
@@ -146,20 +147,20 @@ impl<'a, T> Dijkstra<'a, T> {
                 continue;
             }
 
-            for neighbour in self.iterable.out_neighbors(&vert_meta.id) {
-                if !visited.contains(&neighbour) {
+            for neighbor in self.iterable.out_neighbors(&vert_meta.id) {
+                if !visited.contains(&neighbor) {
                     let mut alt_dist = *self.distances.get(&vert_meta.id).unwrap();
 
-                    if let Some(w) = self.iterable.weight(&vert_meta.id, &neighbour) {
+                    if let Some(w) = self.iterable.weight(&vert_meta.id, &neighbor) {
                         alt_dist += w;
                     }
 
-                    if alt_dist < *self.distances.get(&neighbour).unwrap() {
-                        self.distances.insert(*neighbour, alt_dist);
-                        self.previous.insert(*neighbour, Some(vert_meta.id));
+                    if alt_dist < *self.distances.get(&neighbor).unwrap() {
+                        self.distances.insert(*neighbor, alt_dist);
+                        self.previous.insert(*neighbor, Some(vert_meta.id));
 
                         vertex_pq.push(VertexMeta {
-                            id: *neighbour,
+                            id: *neighbor,
                             distance: alt_dist,
                         });
                     }
@@ -269,12 +270,12 @@ mod tests {
         let v_e = graph.add_vertex(5);
         let v_f = graph.add_vertex(6);
 
-        graph.add_edge_with_weight(&v_a, &v_b, 0.1);
-        graph.add_edge_with_weight(&v_b, &v_d, 0.2);
-        graph.add_edge_with_weight(&v_c, &v_b, 0.5);
-        graph.add_edge_with_weight(&v_c, &v_d, 0.1);
-        graph.add_edge_with_weight(&v_c, &v_e, 0.5);
-        graph.add_edge_with_weight(&v_d, &v_f, 0.8);
+        graph.add_edge_with_weight(&v_a, &v_b, 0.1).unwrap();
+        graph.add_edge_with_weight(&v_b, &v_d, 0.2).unwrap();
+        graph.add_edge_with_weight(&v_c, &v_b, 0.5).unwrap();
+        graph.add_edge_with_weight(&v_c, &v_d, 0.1).unwrap();
+        graph.add_edge_with_weight(&v_c, &v_e, 0.5).unwrap();
+        graph.add_edge_with_weight(&v_d, &v_f, 0.8).unwrap();
 
         {
             let mut iterator = Dijkstra::new(&graph, &v_a).unwrap();
@@ -287,12 +288,12 @@ mod tests {
             assert_eq!(iterator.get_distance(&v_f).unwrap(), 1.1);
         }
 
-        graph.add_edge_with_weight(&v_b, &v_a, 0.1);
-        graph.add_edge_with_weight(&v_d, &v_b, 0.2);
-        graph.add_edge_with_weight(&v_b, &v_c, 0.5);
-        graph.add_edge_with_weight(&v_d, &v_c, 0.1);
-        graph.add_edge_with_weight(&v_e, &v_c, 0.5);
-        graph.add_edge_with_weight(&v_f, &v_d, 0.8);
+        graph.add_edge_with_weight(&v_b, &v_a, 0.1).unwrap();
+        graph.add_edge_with_weight(&v_d, &v_b, 0.2).unwrap();
+        graph.add_edge_with_weight(&v_b, &v_c, 0.5).unwrap();
+        graph.add_edge_with_weight(&v_d, &v_c, 0.1).unwrap();
+        graph.add_edge_with_weight(&v_e, &v_c, 0.5).unwrap();
+        graph.add_edge_with_weight(&v_f, &v_d, 0.8).unwrap();
 
         let mut iterator = Dijkstra::new(&graph, &v_a).unwrap();
 
@@ -313,12 +314,12 @@ mod tests {
         assert_eq!(iterator.get_distance(&v_f).unwrap(), 0.900_000_04);
         // Ugh! I wish there was something like `assert_approx_eq!()`. Too lazy to write on my own.
 
-        assert_eq!(iterator.get_path_to(&v_a).unwrap().count(), 4);
-        assert_eq!(iterator.get_path_to(&v_b).unwrap().count(), 3);
-        assert_eq!(iterator.get_path_to(&v_c).unwrap().count(), 1);
-        assert_eq!(iterator.get_path_to(&v_d).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_e).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_f).unwrap().count(), 3);
+        assert_eq!(iterator.clone().get_path_to(&v_a).unwrap().count(), 4);
+        assert_eq!(iterator.clone().get_path_to(&v_b).unwrap().count(), 3);
+        assert_eq!(iterator.clone().get_path_to(&v_c).unwrap().count(), 1);
+        assert_eq!(iterator.clone().get_path_to(&v_d).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_e).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_f).unwrap().count(), 3);
 
         /*
         // To run these tests, uncomment and use `-- --nocapture` flag in `cargo test`
@@ -347,12 +348,12 @@ mod tests {
         let v_e = graph.add_vertex(5);
         let v_f = graph.add_vertex(6);
 
-        graph.add_edge(&v_a, &v_b);
-        graph.add_edge(&v_b, &v_d);
-        graph.add_edge(&v_c, &v_b);
-        graph.add_edge(&v_c, &v_d);
-        graph.add_edge(&v_c, &v_e);
-        graph.add_edge(&v_d, &v_f);
+        graph.add_edge(&v_a, &v_b).unwrap();
+        graph.add_edge(&v_b, &v_d).unwrap();
+        graph.add_edge(&v_c, &v_b).unwrap();
+        graph.add_edge(&v_c, &v_d).unwrap();
+        graph.add_edge(&v_c, &v_e).unwrap();
+        graph.add_edge(&v_d, &v_f).unwrap();
 
         let mut iterator = Dijkstra::new(&graph, &v_a).unwrap();
 
@@ -363,14 +364,14 @@ mod tests {
         assert_eq!(iterator.get_distance(&v_e).unwrap(), infinity);
         assert_eq!(iterator.get_distance(&v_f).unwrap(), 0.0);
 
-        assert_eq!(iterator.get_path_to(&v_a).unwrap().count(), 1);
-        assert_eq!(iterator.get_path_to(&v_b).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_c).unwrap().count(), 0);
-        assert_eq!(iterator.get_path_to(&v_d).unwrap().count(), 3);
-        assert_eq!(iterator.get_path_to(&v_e).unwrap().count(), 0);
-        assert_eq!(iterator.get_path_to(&v_f).unwrap().count(), 4);
+        assert_eq!(iterator.clone().get_path_to(&v_a).unwrap().count(), 1);
+        assert_eq!(iterator.clone().get_path_to(&v_b).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_c).unwrap().count(), 0);
+        assert_eq!(iterator.clone().get_path_to(&v_d).unwrap().count(), 3);
+        assert_eq!(iterator.clone().get_path_to(&v_e).unwrap().count(), 0);
+        assert_eq!(iterator.clone().get_path_to(&v_f).unwrap().count(), 4);
 
-        iterator.set_source(&v_c);
+        iterator.set_source(&v_c).unwrap();
 
         assert_eq!(iterator.get_distance(&v_a).unwrap(), infinity);
         assert_eq!(iterator.get_distance(&v_b).unwrap(), 0.0);
@@ -379,12 +380,12 @@ mod tests {
         assert_eq!(iterator.get_distance(&v_e).unwrap(), 0.0);
         assert_eq!(iterator.get_distance(&v_f).unwrap(), 0.0);
 
-        assert_eq!(iterator.get_path_to(&v_a).unwrap().count(), 0);
-        assert_eq!(iterator.get_path_to(&v_b).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_c).unwrap().count(), 1);
-        assert_eq!(iterator.get_path_to(&v_d).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_e).unwrap().count(), 2);
-        assert_eq!(iterator.get_path_to(&v_f).unwrap().count(), 3);
+        assert_eq!(iterator.clone().get_path_to(&v_a).unwrap().count(), 0);
+        assert_eq!(iterator.clone().get_path_to(&v_b).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_c).unwrap().count(), 1);
+        assert_eq!(iterator.clone().get_path_to(&v_d).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_e).unwrap().count(), 2);
+        assert_eq!(iterator.clone().get_path_to(&v_f).unwrap().count(), 3);
 
         /*
         // To run these tests, uncomment and use `-- --nocapture` flag in `cargo test`

src/iterators/mod.rs

@@ -5,6 +5,7 @@ mod dfs;
 mod dijkstra;
 mod topo;
 mod vertices;
+mod owning_iterator;
 
 pub use bfs::*;
 pub use dfs::*;

src/iterators/owning_iterator.rs

@@ -0,0 +1,89 @@
+// Copyright 2019 Octavian Oncescu
+
+use crate::vertex_id::VertexId;
+
+#[cfg(feature = "no_std")]
+extern crate alloc;
+
+#[cfg(feature = "no_std")]
+use alloc::boxed::Box;
+
+#[cfg(not(feature = "no_std"))]
+use std::fmt::Debug;
+
+#[cfg(not(feature = "no_std"))]
+use std::marker::PhantomData;
+
+#[cfg(feature = "no_std")]
+use alloc::marker::PhantomData;
+
+#[cfg(feature = "no_std")]
+use alloc::mem;
+
+#[cfg(not(feature = "no_std"))]
+use std::mem;
+
+#[cfg(not(feature = "no_std"))]
+use std::collections::VecDeque;
+
+#[cfg(feature = "no_std")]
+use alloc::collections::VecDeque;
+
+/// Iterator that owns the data.
+#[derive(Debug)]
+pub(crate) struct OwningIterator<'a> {
+    iterable: VecDeque<VertexId>,
+    cur_idx: usize, // Quite the hack, but it works
+    phantom: PhantomData<&'a u8>,
+}
+
+impl<'a> OwningIterator<'a> {
+    pub fn new(iterable: VecDeque<VertexId>) -> Self {
+        OwningIterator {
+            iterable,
+            cur_idx: 0,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a> Iterator for OwningIterator<'a> {
+    type Item = &'a VertexId;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.cur_idx == self.iterable.len() {
+            None
+        } else {
+            let last_idx = self.cur_idx;
+            self.cur_idx += 1;
+
+            // Since we cannot annotate the lifetime 'a to &mut self
+            // because of the Iterator trait's signature, this seems
+            // the only way to make the compiler happy.
+            // 
+            // TODO: If you can make this work with safe Rust, please do.
+            unsafe {
+                let ptr = &self.iterable[last_idx] as *const VertexId;
+                let transmuted = mem::transmute::<*const VertexId, &VertexId>(ptr);
+                Some(transmuted)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_yields_correct_vertex_ids() {
+        let ids: VecDeque<VertexId> = vec![VertexId::random(), VertexId::random(), VertexId::random()].iter().cloned().collect();
+        let mut iter = OwningIterator::new(ids.clone());
+
+        assert_eq!(iter.next(), Some(&ids[0]));
+        assert_eq!(iter.next(), Some(&ids[1]));
+        assert_eq!(iter.next(), Some(&ids[2]));
+        assert_eq!(iter.next(), None);
+    }
+}