Removed arc instances from bfs module

Author: octavonce

src/graph.rs

@@ -974,15 +974,6 @@ impl<T> Graph<T> {
         Bfs::new(self)
     }
 
-    /// Attempts to fetch a reference to a stored vertex id
-    /// which is equal to the given `VertexId`.
-    pub(crate) fn fetch_id_ref<'b>(&'b self, id: &VertexId) -> Option<&'b VertexId> {
-        match self.vertices.get(id) {
-            Some((_, id_ptr)) => Some(id_ptr.as_ref()),
-            None => None,
-        }
-    }
-
     /// Creates a file with the dot representation of the graph.
     /// This method requires the `dot` feature.
     ///
@@ -1024,14 +1015,14 @@ impl<T> Graph<T> {
     }
 
     fn do_add_edge(&mut self, a: &VertexId, b: &VertexId, weight: f32) -> Result<(), GraphErr> {
-        let id_ptr1 = if let Some((_, a_prime)) = self.vertices.get(a) {
-            a_prime.clone()
+        let id_ptr1 = if self.vertices.get(a).is_some() {
+            a.clone()
         } else {
             return Err(GraphErr::NoSuchVertex);
         };
 
-        let id_ptr2 = if let Some((_, b_prime)) = self.vertices.get(b) {
-            b_prime.clone()
+        let id_ptr2 = if self.vertices.get(b).is_some() {
+            b.clone()
         } else {
             return Err(GraphErr::NoSuchVertex);
         };
@@ -1113,6 +1104,15 @@ impl<T> Graph<T> {
         });
     }
 
+    /// Attempts to fetch a reference to a stored vertex id
+    /// which is equal to the given `VertexId`.
+    pub(crate) fn fetch_id_ref<'b>(&'b self, id: &VertexId) -> Option<&'b VertexId> {
+        match self.vertices.get(id) {
+            Some((_, id_ptr)) => Some(id_ptr.as_ref()),
+            None => None,
+        }
+    }
+
     /// Returns a reference to the inner edges hash map.
     fn edges_hm_ref(&self) -> Result<(&HashMap<Edge, f32>), GraphErr> {
         Ok(&self.edges)

src/iterators/bfs.rs

@@ -6,24 +6,22 @@ use crate::vertex_id::VertexId;
 use hashbrown::HashSet;
 #[cfg(not(feature = "no_std"))]
 use std::collections::VecDeque;
-#[cfg(not(feature = "no_std"))]
-use std::sync::Arc;
 
 #[cfg(feature = "no_std")]
 extern crate alloc;
 #[cfg(feature = "no_std")]
-use alloc::{collections::vec_deque::VecDeque, sync::Arc};
+use alloc::{collections::vec_deque::VecDeque};
 
 #[cfg(feature = "no_std")]
 use alloc::vec::Vec;
 
 #[derive(Debug)]
 /// Breadth-First Iterator
 pub struct Bfs<'a, T> {
-    queue: VecDeque<Arc<VertexId>>,
-    current_ptr: Option<Arc<VertexId>>,
-    visited_set: HashSet<Arc<VertexId>>,
-    roots_stack: Vec<Arc<VertexId>>,
+    queue: VecDeque<VertexId>,
+    current_ptr: Option<VertexId>,
+    visited_set: HashSet<VertexId>,
+    roots_stack: Vec<VertexId>,
     iterable: &'a Graph<T>,
 }
 
@@ -32,7 +30,7 @@ impl<'a, T> Bfs<'a, T> {
         let mut roots_stack = Vec::with_capacity(graph.roots_count());
 
         for v in graph.roots() {
-            roots_stack.push(Arc::from(*v));
+            roots_stack.push(v.clone());
         }
 
         let current_ptr = roots_stack.pop();
@@ -66,8 +64,8 @@ impl<'a, T> Iterator for Bfs<'a, T> {
                 // and check their visited status.
                 for n in self.iterable.out_neighbors(current_ptr.as_ref()) {
                     if !self.visited_set.contains(n) {
-                        self.visited_set.insert(Arc::from(*n));
-                        self.queue.push_back(Arc::from(*n));
+                        self.visited_set.insert(n.clone());
+                        self.queue.push_back(n.clone());
 
                         return self.iterable.fetch_id_ref(n);
                     }