The 'HasVertex' property can now provide indexed vertices without const parameter.

Author: Emoun

src/core/property/has_vertex.rs

@@ -8,6 +8,10 @@ use std::{
 };
 
 /// A marker trait for graphs with at least 1 vertex.
+///
+/// `V` is the number of vertices that are guaranteed to be in the graph.
+/// If `Unique` is true (default) then indexed vertices methods will never return duplicate
+/// vertices.
 pub trait HasVertex<const V: usize = 1>: Graph
 {
 	/// Ensures this trait cannot be implemented with V=0.
@@ -45,7 +49,7 @@ pub trait HasVertex<const V: usize = 1>: Graph
 	/// 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 {
+	/// 	fn get_vertex_idx(&self, idx: usize) -> Self::Vertex {
 	/// 		()
 	/// 	}
 	/// }
@@ -64,20 +68,32 @@ pub trait HasVertex<const V: usize = 1>: Graph
 
 	/// Returns a vertex in the graph.
 	///
-	/// Successive calls do not have to return the same vertex,
+	/// Successive calls do not guarantee to return the same vertex,
 	/// even though the graph hasn't changed.
-	///
-	/// This trait doesn't provide a default implementation for `get_vertex`
-	/// 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
 	{
 		_ = Self::ASSERT_NOT_0;
 		self.get_vertex_at::<0>()
 	}
-
-	fn get_vertex_at<const I: usize>(&self) -> Self::Vertex;
+	
+	/// Returns the I'th vertex guaranteed to be in the vertex.
+	///
+	/// The vertex ordering (i.e. the I) is significant and does not change unless
+	/// the underlying graph type changes it.
+	fn get_vertex_at<const I: usize>(&self) -> Self::Vertex {
+		_ = Self::ASSERT_NOT_0;
+		const {
+			assert!(I < V)
+		}
+		assert!(I < V, "I out of bounds");
+		self.get_vertex_idx(I)
+	}
+	
+	/// Returns vertex guaranteed to be in the vertex at the given index in the ordering.
+	///
+	/// The vertex ordering (i.e. the idx) is significant and does not change unless
+	/// the underlying graph type changes it.
+	fn get_vertex_idx(&self, idx: usize) -> Self::Vertex;
 }
 
 /// Ensures the underlying graph has at least 1 vertex.
@@ -119,8 +135,9 @@ where
 
 impl<C: Ensure, const V: usize> HasVertex<V> for HasVertexGraph<C>
 {
-	fn get_vertex_at<const N: usize>(&self) -> Self::Vertex
+	fn get_vertex_idx(&self, idx: usize) -> Self::Vertex
 	{
+		assert!(idx < V);
 		self.all_vertices()
 			.next()
 			.expect("HasVertexGraph has no vertices.")
@@ -132,11 +149,9 @@ impl_ensurer! {
 	as (self.0) : C
 }
 
-/// Ensures a specific vertex is in the underlying graph.
+/// Ensures a specific vertex or vertices is in the underlying graph.
 ///
-/// That vertex is guaranteed to be returned by any call to `get_vertex` and
-/// cannot be removed from the graph.
-
+/// The designated vertices cannot be removed from the graph.
 #[derive(Clone)]
 pub struct VertexInGraph<C: Ensure, const V: usize = 1>(C, [<C::Graph as Graph>::Vertex; V]);
 
@@ -221,10 +236,10 @@ where
 
 impl<C: Ensure, const V: usize> HasVertex<V> for VertexInGraph<C, V>
 {
-	fn get_vertex_at<const N: usize>(&self) -> Self::Vertex
+	fn get_vertex_idx(&self, idx: usize) -> Self::Vertex
 	{
-		// assert!(N < V);
-		self.1[N]
+		assert!(idx < V);
+		self.1[idx]
 	}
 }
 

src/core/property/impl_ensurer.rs

@@ -601,7 +601,7 @@ macro_rules! impl_properties {
 			@implement {
 				delegate::delegate! {
 					to $crate::core::GraphDeref::graph(&self$($delegate)+) {
-						fn get_vertex_at<const N: usize>(&self) -> Self::Vertex;
+						fn get_vertex_idx(&self, idx: usize) -> Self::Vertex;
 					}
 				}
 			}

tests/core/property/has_vertex_rooted.rs

@@ -31,14 +31,34 @@ mod __
 
 			assert!(!HasVertexGraph::can_guard(&null_graph));
 		}
-
-		/// Tests that graphs with at least 1 vertex are accepted.
-		#[quickcheck]
-		fn accept_has_vertex(Arb(g): Arb<VertexInGraph<MockGraph<directedness>>>) -> bool
+		
+		#[duplicate_item(
+			mod_name has_num;
+			[__1] [ 1 ];
+			[__2] [ 2 ];
+			[__3] [ 3 ];
+			[__4] [ 4 ];
+			[__9] [ 9 ];
+		)]
+		mod __
 		{
-			HasVertexGraph::can_guard(&g.release_all())
+			use super::*;
+			
+			/// Tests that graphs with at least has_num>0 vertices are accepted.
+			#[quickcheck]
+			fn accept_has_vertex(Arb(g): Arb<VertexInGraph<MockGraph<directedness>,has_num>>) -> bool
+			{
+				HasVertexGraph::can_guard(&g.release_all())
+			}
+			
+			/// Tests that graphs that already implement HasVertex<has_num>0>.
+			#[quickcheck]
+			fn accept_has_vertex_implemented(Arb(g): Arb<VertexInGraph<MockGraph<directedness>,has_num>>) -> bool
+			{
+				HasVertexGraph::can_guard(&g)
+			}
 		}
-
+		
 		/// Tests cannot remove a vertex if it's the only one in the graph.
 		#[test]
 		fn reject_remove_vertex()
@@ -47,20 +67,20 @@ mod __
 			let v = g
 				.new_vertex_weighted(MockVertexWeight { value: 0 })
 				.unwrap();
-
+				
 			let mut g = HasVertexGraph::guard(g).unwrap();
-
+			
 			assert!(g.remove_vertex(v).is_err())
 		}
-
+		
 		/// Tests that can remove a vertex if there are at least 2.
 		#[quickcheck]
 		fn accept_remove_vertex(Arb(g): Arb<TwoVerticesIn<MockGraph<directedness>, Unique>>)
 			-> bool
 		{
 			let v = g.get_vertex();
 			let mut g = HasVertexGraph::guard(g.release_all()).unwrap();
-
+			
 			g.remove_vertex(v).is_ok()
 		}
 	}

tests/mock_graph/arbitrary/vertex_in_graph.rs

@@ -10,7 +10,7 @@ use quickcheck::Gen;
 use rand::Rng;
 use std::collections::HashSet;
 
-impl<Gr: GuidedArbGraph> GuidedArbGraph for VertexInGraph<Gr>
+impl<Gr: GuidedArbGraph, const V: usize> GuidedArbGraph for VertexInGraph<Gr, V>
 where
 	Gr::Graph: TestGraph,
 	<Gr::Graph as Graph>::EdgeWeight: MockType,
@@ -23,32 +23,36 @@ where
 		e_max: usize,
 	) -> (usize, usize)
 	{
-		assert!(v_max > 1);
-		Gr::choose_size(g, std::cmp::max(v_min, 1), v_max, e_min, e_max)
+		assert!(v_max > V);
+		Gr::choose_size(g, std::cmp::max(v_min, V), v_max, e_min, e_max)
 	}
 
 	fn arbitrary_fixed<G: Gen>(g: &mut G, v_count: usize, e_count: usize) -> Self
 	{
-		assert!(v_count >= 1);
+		assert!(v_count >= V);
 		let graph = Gr::arbitrary_fixed(g, v_count, e_count);
-		let v = graph
-			.graph()
-			.all_vertices()
-			.nth(g.gen_range(0, v_count))
-			.unwrap();
+		
+		// Collect V vertices through elimination
+		let mut all_vs : Vec<_> = graph .graph().all_vertices().collect();
+		while all_vs.len() > V {
+			let remove_idx = g.gen_range(0, all_vs.len());
+			all_vs.remove(remove_idx);
+		}
+		
+		let final_vs : [_;V] =  all_vs.try_into().unwrap();
 
-		Self::ensure_unchecked(graph, [v])
+		Self::ensure_unchecked(graph, final_vs)
 	}
 
 	fn shrink_guided(&self, mut limits: HashSet<Limit>) -> Box<dyn Iterator<Item = Self>>
 	{
-		let v = self.get_vertex();
-		limits.insert(Limit::VertexKeep(v));
+		let vs: [_;V]= (0..V).map(|i| self.get_vertex_idx(i)).collect::<Vec<_>>().try_into().unwrap();
+		vs.iter().for_each(|v| {limits.insert(Limit::VertexKeep(*v));});
 		Box::new(
 			self.clone()
 				.release()
 				.shrink_guided(limits)
-				.map(move |g| Self::ensure_unchecked(g, [v])),
+				.map(move |g| Self::ensure_unchecked(g, vs)),
 		)
 	}
 }