Removed 'TwoVerticesIn' in favor of 'VertexInGraph<_,2,_>'.

Author: Emoun

src/algo/tarjan_scc.rs

@@ -293,7 +293,6 @@ where
 	/// This is similar to `next`, however can be used when `TarjanScc` receives
 	/// a non-copy ensure.
 	///
-	///
 	pub fn next_scc(&mut self) -> Option<ConnectedGraph<SubgraphProxy<&G::Graph>>>
 	{
 		next_scc_impl!(self, .graph())

tests/common/adjacency_list/impl_graph.rs

@@ -3,7 +3,7 @@
 use crate::{
 	common::adjacency_list::adj_list_from_mock,
 	mock_graph::{
-		arbitrary::{Arb, EdgeIn, TwoVerticesIn},
+		arbitrary::{Arb, EdgeIn},
 		utilities::unordered_equivalent_lists_equal,
 		MockGraph,
 	},
@@ -65,9 +65,10 @@ mod __
 	/// Tests that when we create an AdjListGraph from a MockGraph,
 	/// any edge in the mock is in the AdjListGraph
 	#[quickcheck]
-	fn edges_between(Arb(mock): Arb<TwoVerticesIn<MockGraph<directedness>>>) -> bool
+	fn edges_between(Arb(mock): Arb<VertexInGraph<MockGraph<directedness>, 2, false>>) -> bool
 	{
-		let (v1, v2) = mock.get_both();
+		let v1 = mock.vertex_at::<0>();
+		let v2 = mock.vertex_at::<1>();
 		let mock = mock.0.release_all();
 		let (g, v_map) = adj_list_from_mock(&mock);
 
@@ -80,9 +81,10 @@ mod __
 	/// Tests that `edges_between_mut` returns the same edges as its immutable
 	/// version
 	#[quickcheck]
-	fn edges_between_mut(Arb(mock): Arb<TwoVerticesIn<MockGraph<directedness>>>) -> bool
+	fn edges_between_mut(Arb(mock): Arb<VertexInGraph<MockGraph<directedness>, 2, false>>) -> bool
 	{
-		let (v1, v2) = mock.get_both();
+		let v1 = mock.vertex_at::<0>();
+		let v2 = mock.vertex_at::<1>();
 		let mock = mock.0.release_all();
 		let (mut g, v_map) = adj_list_from_mock(&mock);
 

tests/core/graph/edge_lookup_methods.rs

@@ -10,7 +10,7 @@ use graphene::core::{
 	Directed, Edge, Graph, Release, Undirected,
 };
 
-use crate::mock_graph::arbitrary::{Arb, TwoVerticesIn};
+use crate::mock_graph::arbitrary::Arb;
 
 #[duplicate_item(
 	duplicate!{
@@ -37,7 +37,7 @@ use crate::mock_graph::arbitrary::{Arb, TwoVerticesIn};
 			vertices_init			[ let v = g.vertex_at::<0>().clone() ]
 			vertices_init_invalid 	[ let v = g.1 ]
 			closure 				[ |e| if closure_nested {Some((e.other(v),e.2))} else {None} ]
-			arb_graph 				[ VertexInGraph ]
+			arb_graph(G) 			[ VertexInGraph<G, 1, true> ]
 			arb_invalid_graph 		[ VertexOutside ]
 			base_graph 				[ MockGraph<directedness_nested> ]
 		]
@@ -52,7 +52,10 @@ use crate::mock_graph::arbitrary::{Arb, TwoVerticesIn};
 			module					[module_nested]
 			method 					[edges_between]
 			vertices				[ &v, &_v2 ]
-			vertices_init			[let (v, _v2) = g.get_both()]
+			vertices_init			[
+				let v = g.vertex_at::<0>();
+				let _v2 = g.vertex_at::<1>()
+			]
 			vertices_init_invalid 	[let v = g.1;let _v2 = g.2]
 			closure 				[
 				|e| {
@@ -63,7 +66,7 @@ use crate::mock_graph::arbitrary::{Arb, TwoVerticesIn};
 					} else {None}
 				}
 			]
-			arb_graph 				[ TwoVerticesIn ]
+			arb_graph(G) 			[ VertexInGraph<G, 2, false> ]
 			arb_invalid_graph 		[ EdgeOutside ]
 			base_graph 				[ MockGraph<directedness> ]
 		]
@@ -75,7 +78,7 @@ mod module
 
 	/// Ensures that all edges are returned.
 	#[quickcheck]
-	fn returns_all_edges(Arb(g): Arb<arb_graph<base_graph>>) -> bool
+	fn returns_all_edges(Arb(g): Arb<arb_graph([base_graph])>) -> bool
 	{
 		vertices_init;
 		let g = g.release_all();

tests/core/property/acyclic.rs

@@ -59,7 +59,8 @@ mod __
 		weight: MockEdgeWeight,
 	) -> bool
 	{
-		let (v1, v2) = graph.0.get_both();
+		let v1 = graph.0.vertex_at::<0>();
+		let v2 = graph.0.vertex_at::<1>();
 		let edge_count = graph.all_edges().count();
 
 		let mut g = AcyclicGraph::guard_unchecked(graph.release_all());

tests/core/property/connectedness.rs

@@ -1,7 +1,7 @@
 //! Tests the `core::Connected` trait and its ensurer `core::ConnectedGraph`.
 
 use crate::mock_graph::{
-	arbitrary::{Arb, TwoVerticesIn, UnconnectedGraph},
+	arbitrary::{Arb, UnconnectedGraph},
 	MockDirectedness, MockEdgeWeight, MockGraph, MockVertexWeight,
 };
 use duplicate::duplicate_item;
@@ -69,11 +69,12 @@ mod module
 	/// Tests that a graph always accepts adding an edge.
 	#[quickcheck]
 	fn accept_add_edge_weighted(
-		Arb(g): Arb<TwoVerticesIn<arb_connected>>,
+		Arb(g): Arb<VertexInGraph<arb_connected, 2, false>>,
 		e_weight: MockEdgeWeight,
 	) -> bool
 	{
-		let (v1, v2) = g.get_both();
+		let v1 = g.vertex_at::<0>();
+		let v2 = g.vertex_at::<1>();
 		let mut g = connected_graph::guard_unchecked(g.release_all());
 
 		g.add_edge_weighted(&v1, &v2, e_weight).is_ok()
@@ -83,11 +84,12 @@ mod module
 	/// for connectedness
 	#[quickcheck]
 	fn accept_remove_edge_where_weight(
-		Arb(g): Arb<TwoVerticesIn<arb_connected>>,
+		Arb(g): Arb<VertexInGraph<arb_connected, 2, false>>,
 		e_weight: MockEdgeWeight,
 	) -> bool
 	{
-		let (v1, v2) = g.get_both();
+		let v1 = g.vertex_at::<0>();
+		let v2 = g.vertex_at::<1>();
 		let mut g = connected_graph::guard_unchecked(g.release_all());
 		// To ensure we can remove an edge, we first create an edge to remove
 		g.add_edge_weighted(&v1, &v2, e_weight.clone()).unwrap();
@@ -193,14 +195,16 @@ mod module
 	/// graph unconnected
 	#[quickcheck]
 	fn reject_remove_vertex(
-		Arb(g1): Arb<TwoVerticesIn<arb_reject_remove>>,
-		Arb(g2): Arb<TwoVerticesIn<arb_reject_remove>>,
+		Arb(g1): Arb<VertexInGraph<arb_reject_remove, 2, false>>,
+		Arb(g2): Arb<VertexInGraph<arb_reject_remove, 2, false>>,
 		e_weight: MockEdgeWeight,
 		v_weight: MockVertexWeight,
 	) -> bool
 	{
-		let (v11, v12) = g1.get_both();
-		let (v21, v22) = g2.get_both();
+		let v11 = g1.vertex_at::<0>();
+		let v12 = g1.vertex_at::<1>();
+		let v21 = g2.vertex_at::<0>();
+		let v22 = g2.vertex_at::<1>();
 		let mut graph = g1.0.release_all();
 		// We start by joining 2 connected graphs into a unconnected graph with the 2
 		// components

tests/core/property/has_vertex_rooted.rs

@@ -1,13 +1,10 @@
 /// Tests `HasVertexGraph`, VertexInGraph`, and `RootedGraph`
-use crate::mock_graph::arbitrary::Unique;
-use crate::mock_graph::{
-	arbitrary::{Arb, TwoVerticesIn},
-	MockGraph, MockVertexWeight,
-};
+use crate::mock_graph::{arbitrary::Arb, MockGraph, MockVertexWeight};
 use duplicate::duplicate_item;
 use graphene::core::{
 	property::{
-		HasVertex, HasVertexGraph, NewVertex, RemoveVertex, Rooted, RootedGraph, VertexInGraph,
+		HasVertex, HasVertexGraph, NewVertex, RemoveVertex, Rooted, RootedGraph, VertexIn,
+		VertexInGraph,
 	},
 	Directed, Undirected,
 };
@@ -79,8 +76,9 @@ mod __
 
 		/// 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
+		fn accept_remove_vertex(
+			Arb(g): Arb<VertexInGraph<MockGraph<directedness>, 2, true>>,
+		) -> bool
 		{
 			let v = g.any_vertex();
 			let mut g = HasVertexGraph::guard(g.release_all()).unwrap();
@@ -118,10 +116,11 @@ mod __
 		/// the graph
 		#[quickcheck]
 		fn vertex_in_accept_remove_vertex(
-			Arb(g): Arb<TwoVerticesIn<MockGraph<directedness>, Unique>>,
+			Arb(g): Arb<VertexInGraph<MockGraph<directedness>, 2, true>>,
 		) -> bool
 		{
-			let (v1, v2) = g.get_both();
+			let v1 = g.vertex_at::<0>();
+			let v2 = g.vertex_at::<1>();
 			let mut g = GraphStruct::ensure_unchecked(g.release_all().0, ensure_wrap([v1]));
 
 			g.remove_vertex(v2).is_ok()
@@ -151,9 +150,10 @@ mod __
 		/// Tests that the graph can change the specific underlying
 		/// vertex
 		#[quickcheck]
-		fn set_vertex(Arb(g): Arb<TwoVerticesIn<MockGraph<directedness>, Unique>>) -> bool
+		fn set_vertex(Arb(g): Arb<VertexInGraph<MockGraph<directedness>, 2, true>>) -> bool
 		{
-			let (v1, v2) = g.get_both();
+			let v1 = g.vertex_at::<0>();
+			let v2 = g.vertex_at::<1>();
 			let mut g = GraphStruct::ensure_unchecked(g.release_all().0, ensure_wrap([v1]));
 
 			g.set_method(ensure_wrap([v2])).is_ok() && g.get_method() == v2
@@ -187,10 +187,11 @@ mod __
 
 	/// Tests that RootedGraphs `is_root` returns false when not given the root
 	#[quickcheck]
-	fn is_root_false(Arb(g): Arb<TwoVerticesIn<MockGraph<directedness>, Unique>>) -> bool
+	fn is_root_false(Arb(g): Arb<VertexInGraph<MockGraph<directedness>, 2, true>>) -> bool
 	{
 		use graphene::core::{Ensure, Release};
-		let (v1, v2) = g.get_both();
+		let v1 = g.vertex_at::<0>();
+		let v2 = g.vertex_at::<1>();
 		let g = RootedGraph::ensure_unchecked(g.release_all(), v1);
 
 		!g.is_root(v2)

tests/mock_graph/arbitrary/combinations/mod.rs

@@ -1,11 +1,9 @@
 mod edge_in;
 mod edge_outside;
 mod two_reachable_vertices;
-mod two_vertices_in;
 mod vertex_outside;
 mod vertices_in;
 
 pub use self::{
-	edge_in::*, edge_outside::*, two_reachable_vertices::*, two_vertices_in::*, vertex_outside::*,
-	vertices_in::*,
+	edge_in::*, edge_outside::*, two_reachable_vertices::*, vertex_outside::*, vertices_in::*,
 };

tests/mock_graph/arbitrary/combinations/two_reachable_vertices.rs

@@ -1,11 +1,11 @@
 use crate::mock_graph::{
-	arbitrary::{GuidedArbGraph, Limit, NonUnique, TwoVerticesIn, Uniqueness},
+	arbitrary::{GuidedArbGraph, Limit},
 	MockType, TestGraph,
 };
 use graphene::{
 	algo::{Bfs, Dfs},
 	core::{
-		property::{AddEdge, RemoveEdge, VertexInGraph},
+		property::{AddEdge, RemoveEdge, VertexIn, VertexInGraph},
 		Ensure, Graph, GraphDerefMut, Release,
 	},
 	impl_ensurer,
@@ -16,35 +16,34 @@ use std::{collections::HashSet, fmt::Debug};
 
 /// An arbitrary graph and two vertices in it.
 ///
+/// Guarantees that the second vertex is reachable from the first.
+///
 /// Depending on `U`, the two vertices are either allowed to be the same
 /// (`NonUnique`, default), or they must be unique (`Unique`).
 ///
 /// Note: All graphs will have at least 1 vertex for non-unique and 2 vertices
 /// for unique, meaning this type never includes the empty graph.
 #[derive(Clone, Debug)]
-pub struct TwoReachableVerticesIn<G, U = NonUnique>(pub TwoVerticesIn<G, U>)
+pub struct TwoReachableVerticesIn<G, const UNIQUE: bool = false>(pub VertexInGraph<G, 2, UNIQUE>)
 where
 	G: GuidedArbGraph,
 	G::Graph: TestGraph,
-	<G::Graph as Graph>::EdgeWeight: MockType,
-	U: Uniqueness;
+	<G::Graph as Graph>::EdgeWeight: MockType;
 
 impl_ensurer! {
-	use<G,U> TwoReachableVerticesIn<G,U>
-	as (self.0): TwoVerticesIn<G,U>
+	use<G; const U: bool> TwoReachableVerticesIn<G,U>
+	as (self.0): VertexInGraph<G, 2, U>
 	where
 	G: GuidedArbGraph,
 	G::Graph: TestGraph,
 	<G::Graph as Graph>::EdgeWeight: MockType,
-	U: Uniqueness
 }
 
-impl<Gr, U> GuidedArbGraph for TwoReachableVerticesIn<Gr, U>
+impl<Gr, const U: bool> GuidedArbGraph for TwoReachableVerticesIn<Gr, U>
 where
 	Gr: GuidedArbGraph + GraphDerefMut,
 	Gr::Graph: TestGraph + RemoveEdge + AddEdge,
 	<Gr::Graph as Graph>::EdgeWeight: MockType,
-	U: 'static + Uniqueness,
 {
 	fn choose_size<G: Gen>(
 		g: &mut G,
@@ -58,15 +57,13 @@ where
 
 		// we need at least 1 edge. We'll delegate to TwoVerticesIn to ensure we get
 		// at least 1 or 2 vertices (depending on U).
-		TwoVerticesIn::<Gr, U>::choose_size(g, v_min, v_max, std::cmp::max(e_min, 1), e_max)
+		VertexInGraph::<Gr, 2, U>::choose_size(g, v_min, v_max, std::cmp::max(e_min, 1), e_max)
 	}
 
 	fn arbitrary_fixed<G: Gen>(g: &mut G, v_count: usize, e_count: usize) -> Self
 	{
 		// Create a graph with at least 1 or 2 vertices (1 for non-unique, 2 for Unique)
-		let graph = TwoVerticesIn::<Gr, U>::arbitrary_fixed(g, v_count, e_count)
-			.release()
-			.release();
+		let graph = VertexInGraph::<Gr, 2, U>::arbitrary_fixed(g, v_count, e_count).release();
 
 		let mut vert_reachables: Vec<_> = graph
 			.graph()
@@ -81,7 +78,7 @@ where
 				graph.graph(),
 				[v.clone()],
 			)));
-			if !U::unique() && graph.graph().edges_between(v.clone(), v.clone()).count() > 0
+			if !U && graph.graph().edges_between(v.clone(), v.clone()).count() > 0
 			{
 				reachable.push(v.clone());
 			}
@@ -100,13 +97,14 @@ where
 		// Choose a vertex that ends the path
 		let v2 = reachable[g.gen_range(0, reachable.len())];
 
-		Self(TwoVerticesIn::new(graph, v1.clone(), v2))
+		Self(VertexInGraph::ensure_unchecked(graph, [v1.clone(), v2]))
 	}
 
 	fn shrink_guided(&self, mut limits: HashSet<Limit>) -> Box<dyn Iterator<Item = Self>>
 	{
 		let mut result: Vec<Self> = Vec::new();
-		let (v1, v2) = self.0.get_both();
+		let v1 = self.0.vertex_at::<0>();
+		let v2 = self.0.vertex_at::<1>();
 
 		// First find a path between the vertices
 		let g = VertexInGraph::ensure_unchecked(self, [v1]);
@@ -137,7 +135,7 @@ where
 			clone
 				.0
 				.shrink_guided(limits)
-				.map(|g| Self(TwoVerticesIn::new(g.release(), v1, v2)))
+				.map(|g| Self(VertexInGraph::ensure_unchecked(g, [v1, v2])))
 		});
 
 		// Shrink by either removing superfluous edges from last link
@@ -168,8 +166,8 @@ where
 			{
 				g.add_edge_weighted(v1, v1, w).unwrap();
 			}
-			g.1 = v2;
-			result.push(Self(g));
+			let g = g.release();
+			result.push(Self(VertexInGraph::ensure_unchecked(g, [v1, v2])));
 		}
 		Box::new(result.into_iter())
 	}