The 'HasVertex' is now paramentric on the number of vertices guaranteed to be in the graph.

'VertexInGraph' now accepts a slice of vertices that are guaranteed to
be in the graph.

Author: Emoun

Cargo.toml

@@ -24,9 +24,9 @@ tt-equal = "0.1"
 tt-call = "1.0"
 num-traits = "0.2"
 duplicate = "2.0.0"
+static_assertions = "1.1.0"
 
 [dev-dependencies]
 rand = "0.7"
 quickcheck = "0.9"
 quickcheck_macros = "0.9"
-static_assertions = "1.1.0"

src/algo/bfs.rs

@@ -44,7 +44,7 @@ use std::collections::VecDeque;
 /// graph.add_edge(&v1,&v3).unwrap();
 ///
 /// // We use `VertexInGraph` to ensure traversal starts at v0.
-/// let graph = VertexInGraph::ensure(graph, v0).unwrap();
+/// let graph = VertexInGraph::ensure(graph, [v0]).unwrap();
 ///
 /// // Initialize the traversal
 /// let mut dfs = Bfs::new(&graph);

src/algo/dfs.rs

@@ -42,7 +42,7 @@ use std::borrow::Borrow;
 /// graph.add_edge(&v1,&v2).unwrap();
 ///
 /// // We use `VertexInGraph` to ensure traversal starts at v0.
-/// let graph = VertexInGraph::ensure(graph, v0).unwrap();
+/// let graph = VertexInGraph::ensure(graph, [v0]).unwrap();
 ///
 /// // Initialize the traversal
 /// let mut dfs = Dfs::new_simple(&graph);

src/algo/mod.rs

@@ -4,6 +4,7 @@ mod bfs;
 mod dfs;
 mod dijkstra_shortest_paths;
 mod tarjan_scc;
+mod shortest_path;
 
 pub use self::{bfs::*, dfs::*, dijkstra_shortest_paths::*, tarjan_scc::*};
 use crate::core::{property::VertexInGraph, Ensure, Graph};
@@ -15,7 +16,7 @@ pub fn path_exists<G: Graph>(
 	sink: impl Borrow<G::Vertex>,
 ) -> bool
 {
-	if let Ok(g) = VertexInGraph::ensure(g, source.borrow().clone())
+	if let Ok(g) = VertexInGraph::ensure(g, [source.borrow().clone()])
 	{
 		if g.contains_vertex(sink.borrow())
 		{

src/common/ensured.rs

@@ -20,7 +20,7 @@ impl<G: Ensure> EnsuredGraph<G>
 	{
 		if self.0.graph().contains_vertex(v)
 		{
-			Some(VertexInGraph::ensure_unchecked(self.0, v))
+			Some(VertexInGraph::ensure_unchecked(self.0, [v]))
 		}
 		else
 		{
@@ -39,7 +39,7 @@ where
 	) -> Result<VertexInGraph<G>, ()>
 	{
 		let v = self.0.graph_mut().new_vertex_weighted(w)?;
-		Ok(VertexInGraph::ensure_unchecked(self.0, v))
+		Ok(VertexInGraph::ensure_unchecked(self.0, [v]))
 	}
 
 	pub fn new_vertex(self) -> Result<VertexInGraph<G>, ()>

src/core/property/acyclic.rs

@@ -73,7 +73,7 @@ impl<C: Ensure> Ensure for AcyclicGraph<C>
 			if !done.contains(&v)
 			{
 				done.push(v); // not returned by the dfs
-				let g = VertexInGraph::ensure_unchecked(c.graph(), v);
+				let g = VertexInGraph::ensure_unchecked(c.graph(), [v]);
 				let dfs = Dfs::new(&g, on_visit, on_exit, on_explore, (Vec::new(), &mut result));
 
 				dfs.for_each(|v| {

src/core/property/connected.rs

@@ -56,7 +56,7 @@ pub trait Connected: Unilateral
 	{
 		self.all_vertices()
 			.fold(Self::EdgeWeight::zero(), |max_ecc, v| {
-				let new_ecc = VertexInGraph::ensure_unchecked(self, v).eccentricity();
+				let new_ecc = VertexInGraph::ensure_unchecked(self, [v]).eccentricity();
 				if new_ecc > max_ecc
 				{
 					new_ecc
@@ -80,7 +80,7 @@ pub trait Connected: Unilateral
 	{
 		self.all_vertices()
 			.fold(Self::EdgeWeight::zero(), |min_ecc, v| {
-				let new_ecc = VertexInGraph::ensure_unchecked(self, v).eccentricity();
+				let new_ecc = VertexInGraph::ensure_unchecked(self, [v]).eccentricity();
 				if new_ecc < min_ecc
 				{
 					new_ecc
@@ -104,7 +104,7 @@ pub trait Connected: Unilateral
 	{
 		let radius = self.radius();
 		self.all_vertices()
-			.filter(move |v| VertexInGraph::ensure_unchecked(self, *v).eccentricity() == radius)
+			.filter(move |v| VertexInGraph::ensure_unchecked(self, [*v]).eccentricity() == radius)
 	}
 }
 

src/core/property/has_vertex.rs

@@ -1,12 +1,67 @@
-use crate::core::{property::RemoveVertex, Ensure, Graph, GraphDerefMut};
+use crate::core::{
+	property::{RemoveVertex, Rooted},
+	Ensure, Graph, GraphDerefMut,
+};
 use std::{
 	borrow::Borrow,
 	fmt::{Debug, Error, Formatter},
 };
 
 /// A marker trait for graphs with at least 1 vertex.
-pub trait HasVertex: Graph
+pub trait HasVertex<const V: usize = 1>: Graph
 {
+	/// Ensures this trait cannot be implemented with V=0.
+	///
+	/// Add a call to this associated type in the implementing type's
+	/// constructor to ensure if that type ever gets v=0, compilation will
+	/// fail.
+	///
+	/// Example:
+	/// ```compile_fail, E0080
+	/// # use std::borrow::Borrow;
+	/// # use graphene::{
+	/// # 	common::AdjListGraph,
+	/// # 	core::{Directed, Graph, property::HasVertex}
+	/// # };
+	/// # impl<const V: usize> Graph for Struct<V> {
+	/// # 	type Vertex = ();
+	/// # 	type VertexWeight = ();
+	/// # 	type EdgeWeight = ();
+	/// # 	type EdgeWeightRef<'a> = () where Self: 'a;
+	/// # 	type Directedness = Directed;
+	/// #
+	/// # 	fn all_vertices_weighted(&self) -> impl Iterator<Item=(Self::Vertex, &Self::VertexWeight)>
+	/// # 	{
+	/// #         std::iter::empty()
+	/// # 	}
+	/// #
+	/// # 	fn edges_between(&self, source: impl Borrow<Self::Vertex>, sink: impl Borrow<Self::Vertex>)
+	/// # 		-> impl Iterator<Item=Self::EdgeWeightRef<'_>>
+	/// # 	{
+	/// # 		std::iter::empty()
+	/// # 	}
+	/// #
+	/// # }
+	/// struct Struct<const V: usize>(usize);
+	///
+	/// impl<const V: usize> HasVertex<V> for Struct<V> {
+	/// 	fn get_vertex_at<const N:usize>(&self) -> Self::Vertex {
+	/// 		()
+	/// 	}
+	/// }
+	///
+	/// impl<const V: usize> Struct<V> {
+	/// 	fn new() -> Self {
+	/// 		_ = Self::ASSERT_NOT_0; // This ensures errors are thrown if V = 0
+	/// 		Struct(V)
+	/// 	}
+	/// }
+	///
+	/// let _ = Struct::<0>::new(); // Will cause a compile error
+	/// let _ = Struct::<1>::new(); // Will compile successfully
+	/// ```
+	const ASSERT_NOT_0: () = assert!(V > 0, "Found type implementing HasVertex<0>");
+
 	/// Returns a vertex in the graph.
 	///
 	/// Successive calls do not have to return the same vertex,
@@ -16,7 +71,13 @@ pub trait HasVertex: Graph
 	/// to ensure that "wrapping" ensurers don't accidentally use it, instead
 	/// of actively delegating to the inner class, who might have its own
 	/// implementation.
-	fn get_vertex(&self) -> Self::Vertex;
+	fn get_vertex(&self) -> Self::Vertex
+	{
+		_ = Self::ASSERT_NOT_0;
+		self.get_vertex_at::<0>()
+	}
+
+	fn get_vertex_at<const I: usize>(&self) -> Self::Vertex;
 }
 
 /// Ensures the underlying graph has at least 1 vertex.
@@ -56,9 +117,9 @@ where
 	}
 }
 
-impl<C: Ensure> HasVertex for HasVertexGraph<C>
+impl<C: Ensure, const V: usize> HasVertex<V> for HasVertexGraph<C>
 {
-	fn get_vertex(&self) -> Self::Vertex
+	fn get_vertex_at<const N: usize>(&self) -> Self::Vertex
 	{
 		self.all_vertices()
 			.next()
@@ -75,16 +136,36 @@ impl_ensurer! {
 ///
 /// That vertex is guaranteed to be returned by any call to `get_vertex` and
 /// cannot be removed from the graph.
+
 #[derive(Clone)]
-pub struct VertexInGraph<C: Ensure>(C, <C::Graph as Graph>::Vertex);
+pub struct VertexInGraph<C: Ensure, const V: usize = 1>(C, [<C::Graph as Graph>::Vertex; V]);
 
-impl<C: Ensure> VertexInGraph<C>
+impl<C: Ensure, const V: usize> VertexInGraph<C, V>
 {
-	pub fn set_vertex(&mut self, v: impl Borrow<<C::Graph as Graph>::Vertex>) -> Result<(), ()>
+	/// ```compile_fail, E0080
+	/// use graphene::common::AdjListGraph;
+	/// use graphene::core::property::VertexInGraph;
+	/// use graphene::core::Ensure;
+	///
+	/// 	let _ = VertexInGraph::<_, 0>::ensure_unchecked(AdjListGraph::<(), ()>::new(), []);
+	/// ```
+	fn new(c: C, vs: [<C::Graph as Graph>::Vertex; V]) -> Self
 	{
-		if self.0.graph().contains_vertex(v.borrow())
+		_ = Self::ASSERT_NOT_0;
+		Self(c, vs)
+	}
+
+	pub fn set_vertex(
+		&mut self,
+		replacements: impl Borrow<[<C::Graph as Graph>::Vertex; V]>,
+	) -> Result<(), ()>
+	{
+		if replacements
+			.borrow()
+			.iter()
+			.all(|v| self.0.graph().contains_vertex(v))
 		{
-			self.1 = v.borrow().clone();
+			self.1 = replacements.borrow().clone();
 			Ok(())
 		}
 		else
@@ -94,7 +175,7 @@ impl<C: Ensure> VertexInGraph<C>
 	}
 }
 
-impl<C: Ensure> Debug for VertexInGraph<C>
+impl<C: Ensure, const V: usize> Debug for VertexInGraph<C, V>
 where
 	C: Debug,
 	<C::Graph as Graph>::Vertex: Debug,
@@ -108,26 +189,26 @@ where
 	}
 }
 
-impl<C: Ensure> Ensure for VertexInGraph<C>
+impl<C: Ensure, const V: usize> Ensure for VertexInGraph<C, V>
 {
-	fn ensure_unchecked(c: Self::Ensured, v: <C::Graph as Graph>::Vertex) -> Self
+	fn ensure_unchecked(c: Self::Ensured, v: [<C::Graph as Graph>::Vertex; V]) -> Self
 	{
-		Self(c, v)
+		Self::new(c, v)
 	}
 
-	fn can_ensure(c: &Self::Ensured, p: &<C::Graph as Graph>::Vertex) -> bool
+	fn can_ensure(c: &Self::Ensured, p: &[<C::Graph as Graph>::Vertex; V]) -> bool
 	{
-		c.graph().contains_vertex(*p)
+		p.iter().all(|v| c.graph().contains_vertex(v))
 	}
 }
 
-impl<C: Ensure + GraphDerefMut> RemoveVertex for VertexInGraph<C>
+impl<C: Ensure + GraphDerefMut, const V: usize> RemoveVertex for VertexInGraph<C, V>
 where
 	C::Graph: RemoveVertex,
 {
 	fn remove_vertex(&mut self, v: impl Borrow<Self::Vertex>) -> Result<Self::VertexWeight, ()>
 	{
-		if self.1.borrow() != v.borrow()
+		if self.1.iter().all(|v2| v2 != v.borrow())
 		{
 			self.0.graph_mut().remove_vertex(v)
 		}
@@ -138,16 +219,32 @@ where
 	}
 }
 
-impl<C: Ensure> HasVertex for VertexInGraph<C>
+impl<C: Ensure, const V: usize> HasVertex<V> for VertexInGraph<C, V>
 {
-	fn get_vertex(&self) -> Self::Vertex
+	fn get_vertex_at<const N: usize>(&self) -> Self::Vertex
+	{
+		// assert!(N < V);
+		self.1[N]
+	}
+}
+
+impl<C: Ensure> Rooted for VertexInGraph<C>
+where
+	C::Graph: Rooted,
+{
+	fn root(&self) -> Self::Vertex
+	{
+		self.get_vertex()
+	}
+
+	fn set_root(&mut self, v: impl Borrow<Self::Vertex>) -> Result<(), ()>
 	{
-		self.1
+		self.set_vertex([*v.borrow()])
 	}
 }
 
 impl_ensurer! {
-	use<C> VertexInGraph<C>: Ensure, HasVertex, RemoveVertex
+	use<C ; const V: usize> VertexInGraph<C,V>: Ensure, HasVertex, RemoveVertex, Rooted
 	as (self.0) : C
-	as (self.1) : <C::Graph as Graph>::Vertex
+	as (self.1) : [<C::Graph as Graph>::Vertex;V]
 }