Added 'proxy::EdgeWeightMap'

'DijkstraShortestPaths', 'Spfs', and 'Connected::*' now only take graphs
with integer weights.
EdgeWeightMap is used to wrap other graphs.

Simplified 'Graph' (and other traits) method lifetime requirements.

Author: Emoun

src/algo/dijkstra_shortest_paths.rs

@@ -1,40 +1,38 @@
 use crate::core::{property::HasVertex, Edge, Graph};
-use num_traits::{PrimInt, Unsigned};
+use num_traits::{PrimInt, Unsigned, Zero};
 use std::borrow::Borrow;
 
 /// [Dijkstra's shortest paths algorithm](https://mathworld.wolfram.com/DijkstrasAlgorithm.html)
-pub struct DijkstraShortestPaths<'a, G, W>
+pub struct DijkstraShortestPaths<'a, G>
 where
 	G: 'a + Graph,
-	W: PrimInt + Unsigned,
+	G::EdgeWeight: PrimInt + Unsigned,
 {
 	graph: &'a G,
 	visited: Vec<G::Vertex>,
 	// We keep it sorted with the lowest weight at the end for efficiency.
-	queue: Vec<(W, (G::Vertex, G::Vertex, G::EdgeWeightRef<'a>))>,
-	get_distance: fn(&G::EdgeWeight) -> W,
+	queue: Vec<(G::EdgeWeight, (G::Vertex, G::Vertex, G::EdgeWeightRef<'a>))>,
 }
 
-impl<'a, G, W> DijkstraShortestPaths<'a, G, W>
+impl<'a, G> DijkstraShortestPaths<'a, G>
 where
 	G: 'a + Graph,
-	W: PrimInt + Unsigned,
+	G::EdgeWeight: PrimInt + Unsigned,
 {
-	pub fn new(graph: &'a G, get_distance: fn(&G::EdgeWeight) -> W) -> Self
+	pub fn new(graph: &'a G) -> Self
 	where
 		G: HasVertex,
 	{
 		let mut dijk = Self {
 			graph,
 			visited: Vec::new(),
 			queue: Vec::new(),
-			get_distance,
 		};
-		dijk.visit(graph.get_vertex(), W::zero());
+		dijk.visit(graph.get_vertex(), G::EdgeWeight::zero());
 		dijk
 	}
 
-	fn visit(&mut self, v: G::Vertex, w: W)
+	fn visit(&mut self, v: G::Vertex, w: G::EdgeWeight)
 	{
 		self.visited.push(v);
 		let visited = &self.visited;
@@ -44,7 +42,7 @@ where
 
 		for (sink, weight) in edges
 		{
-			let new_weight = w + (self.get_distance)(weight.borrow());
+			let new_weight = w + *weight.borrow();
 			if let Some((old_weight, old_edge)) = self
 				.queue
 				.iter_mut()
@@ -66,42 +64,25 @@ where
 
 	/// Returns the vertices reachable from the designated vertex and the
 	/// weighted distance to them
-	pub fn distances(
-		graph: &'a G,
-		get_distance: fn(&G::EdgeWeight) -> W,
-	) -> impl 'a + Iterator<Item = (G::Vertex, W)>
+	pub fn distances(graph: &'a G) -> impl 'a + Iterator<Item = (G::Vertex, G::EdgeWeight)>
 	where
 		G: HasVertex,
-		W: 'a,
 	{
-		let mut distances = vec![(graph.get_vertex(), W::zero())];
+		let mut distances = vec![(graph.get_vertex(), G::EdgeWeight::zero())];
 
-		DijkstraShortestPaths::new(graph, get_distance).map(move |(so, si, w)| {
+		DijkstraShortestPaths::new(graph).map(move |(so, si, w)| {
 			let dist = distances.iter().find(|(v, _)| so == *v).unwrap().1;
-			let new_dist = dist + get_distance(w.borrow());
+			let new_dist = dist + *w.borrow();
 			distances.push((si, new_dist));
 			(si, new_dist)
 		})
 	}
 }
 
-impl<'a, G> DijkstraShortestPaths<'a, G, G::EdgeWeight>
+impl<'a, G> Iterator for DijkstraShortestPaths<'a, G>
 where
 	G: 'a + Graph,
 	G::EdgeWeight: PrimInt + Unsigned,
-{
-	pub fn new_simple(graph: &'a G) -> Self
-	where
-		G: HasVertex,
-	{
-		Self::new(graph, Clone::clone)
-	}
-}
-
-impl<'a, G, W> Iterator for DijkstraShortestPaths<'a, G, W>
-where
-	G: 'a + Graph,
-	W: PrimInt + Unsigned,
 {
 	type Item = (G::Vertex, G::Vertex, G::EdgeWeightRef<'a>);
 
@@ -118,46 +99,33 @@ where
 /// Shortest-Path-First search
 ///
 /// next() doesn't return the starting vertex.
-pub struct Spfs<'a, G, W>
+pub struct Spfs<'a, G>
 where
 	G: 'a + Graph,
-	W: PrimInt + Unsigned,
+	G::EdgeWeight: PrimInt + Unsigned,
 {
-	dijk: DijkstraShortestPaths<'a, G, W>,
+	dijk: DijkstraShortestPaths<'a, G>,
 }
 
-impl<'a, G, W> Spfs<'a, G, W>
+impl<'a, G> Spfs<'a, G>
 where
 	G: 'a + Graph,
-	W: PrimInt + Unsigned,
+	G::EdgeWeight: PrimInt + Unsigned,
 {
-	pub fn new(graph: &'a G, get_weight: fn(&G::EdgeWeight) -> W) -> Self
+	pub fn new(graph: &'a G) -> Self
 	where
 		G: HasVertex,
 	{
 		Self {
-			dijk: DijkstraShortestPaths::new(graph, get_weight),
+			dijk: DijkstraShortestPaths::new(graph),
 		}
 	}
 }
 
-impl<'a, G> Spfs<'a, G, G::EdgeWeight>
+impl<'a, G> Iterator for Spfs<'a, G>
 where
 	G: 'a + Graph,
 	G::EdgeWeight: PrimInt + Unsigned,
-{
-	pub fn new_simple(graph: &'a G) -> Self
-	where
-		G: HasVertex,
-	{
-		Self::new(graph, Clone::clone)
-	}
-}
-
-impl<'a, G, W> Iterator for Spfs<'a, G, W>
-where
-	G: 'a + Graph,
-	W: PrimInt + Unsigned,
 {
 	type Item = G::Vertex;
 

src/common/adjacency_list/impl_graph.rs

@@ -25,11 +25,11 @@ where
 		self.vertices.iter().enumerate().map(|(v, (w, _))| (v, w))
 	}
 
-	fn edges_between<'a: 'b, 'b>(
-		&'a self,
-		source: impl 'b + Borrow<Self::Vertex>,
-		sink: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = Self::EdgeWeightRef<'a>>
+	fn edges_between(
+		&self,
+		source: impl Borrow<Self::Vertex>,
+		sink: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = Self::EdgeWeightRef<'_>>
 	{
 		let source = source.borrow().clone();
 		let sink = sink.borrow().clone();
@@ -75,19 +75,19 @@ where
 {
 	fn all_vertices_weighted_mut(
 		&mut self,
-	) -> impl '_ + Iterator<Item = (Self::Vertex, &mut Self::VertexWeight)>
+	) -> impl Iterator<Item = (Self::Vertex, &mut Self::VertexWeight)>
 	{
 		self.vertices
 			.iter_mut()
 			.enumerate()
 			.map(|(v, (w, _))| (v, w))
 	}
 
-	fn edges_between_mut<'a: 'b, 'b>(
-		&'a mut self,
-		source: impl 'b + Borrow<Self::Vertex>,
-		sink: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = &'a mut Self::EdgeWeight>
+	fn edges_between_mut(
+		&mut self,
+		source: impl Borrow<Self::Vertex>,
+		sink: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = &mut Self::EdgeWeight>
 	{
 		let source = source.borrow().clone();
 		let sink = sink.borrow().clone();

src/core/graph.rs

@@ -91,18 +91,18 @@ pub trait Graph
 	///
 	/// If the graph is undirected, returns all edges connecting the two
 	/// vertices. I.e. all edges where e == (v1,v2,_) or e == (v2,v1,_)
-	fn edges_between<'a: 'b, 'b>(
-		&'a self,
-		source: impl 'b + Borrow<Self::Vertex>,
-		sink: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = Self::EdgeWeightRef<'a>>;
+	fn edges_between(
+		&self,
+		source: impl Borrow<Self::Vertex>,
+		sink: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = Self::EdgeWeightRef<'_>>;
 
 	// Optional methods
 
 	/// Returns copies of all current edges in the graph.
 	fn all_edges(
 		&self,
-	) -> impl '_ + Iterator<Item = (Self::Vertex, Self::Vertex, Self::EdgeWeightRef<'_>)>
+	) -> impl Iterator<Item = (Self::Vertex, Self::Vertex, Self::EdgeWeightRef<'_>)>
 	{
 		let mut finished = Vec::new();
 		self.all_vertices()
@@ -124,7 +124,7 @@ pub trait Graph
 			})
 	}
 
-	fn all_vertices(&self) -> impl '_ + Iterator<Item = Self::Vertex>
+	fn all_vertices(&self) -> impl Iterator<Item = Self::Vertex>
 	{
 		self.all_vertices_weighted().map(|(v, _)| v)
 	}
@@ -146,7 +146,7 @@ pub trait Graph
 		iter.into_iter().all(|v| self.contains_vertex(v))
 	}
 
-	fn all_vertex_weights(&self) -> impl '_ + Iterator<Item = &Self::VertexWeight>
+	fn all_vertex_weights(&self) -> impl Iterator<Item = &Self::VertexWeight>
 	{
 		self.all_vertices_weighted().map(|(_, w)| w)
 	}
@@ -156,10 +156,10 @@ pub trait Graph
 	///
 	/// If the graph is undirected, is semantically equivalent to
 	/// `edges_incident_on`.
-	fn edges_sourced_in<'a: 'b, 'b>(
-		&'a self,
-		v: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'a>)>
+	fn edges_sourced_in(
+		&self,
+		v: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'_>)>
 	{
 		self.all_vertices().flat_map(move |v2| {
 			self.edges_between(v.borrow().clone(), v2.borrow().clone())
@@ -172,10 +172,10 @@ pub trait Graph
 	///
 	/// If the graph is undirected, is semantically equivalent to
 	/// `edges_incident_on`.
-	fn edges_sinked_in<'a: 'b, 'b>(
-		&'a self,
-		v: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'a>)>
+	fn edges_sinked_in(
+		&self,
+		v: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'_>)>
 	{
 		self.all_vertices().flat_map(move |v2| {
 			self.edges_between(v2.borrow().clone(), v.borrow().clone())
@@ -187,10 +187,10 @@ pub trait Graph
 	/// on the given vertex.
 	///
 	/// If the graph is directed, edge directions are ignored.
-	fn edges_incident_on<'a: 'b, 'b>(
-		&'a self,
-		v: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'a>)>
+	fn edges_incident_on(
+		&self,
+		v: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = (Self::Vertex, Self::EdgeWeightRef<'_>)>
 	{
 		self.edges_sourced_in(v.borrow().clone()).chain(
 			self.edges_sinked_in(v.borrow().clone())
@@ -200,10 +200,7 @@ pub trait Graph
 
 	/// Returns any vertices connected to the given one with an edge regardless
 	/// of direction.
-	fn vertex_neighbors<'a: 'b, 'b>(
-		&'a self,
-		v: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = Self::Vertex>
+	fn vertex_neighbors(&self, v: impl Borrow<Self::Vertex>) -> impl Iterator<Item = Self::Vertex>
 	{
 		self.all_vertices()
 			.filter(move |other| self.neighbors(v.borrow(), other.borrow()))
@@ -234,13 +231,13 @@ pub trait GraphMut: Graph
 {
 	fn all_vertices_weighted_mut(
 		&mut self,
-	) -> impl '_ + Iterator<Item = (Self::Vertex, &mut Self::VertexWeight)>;
+	) -> impl Iterator<Item = (Self::Vertex, &mut Self::VertexWeight)>;
 
-	fn edges_between_mut<'a: 'b, 'b>(
-		&'a mut self,
-		source: impl 'b + Borrow<Self::Vertex>,
-		sink: impl 'b + Borrow<Self::Vertex>,
-	) -> impl 'b + Iterator<Item = &'a mut Self::EdgeWeight>;
+	fn edges_between_mut(
+		&mut self,
+		source: impl Borrow<Self::Vertex>,
+		sink: impl Borrow<Self::Vertex>,
+	) -> impl Iterator<Item = &mut Self::EdgeWeight>;
 
 	// Optional methods