GCI update

include/graph/adj_list/adjacency_list_concepts.hpp

@@ -20,34 +20,33 @@ namespace graph::adj_list {
 // =============================================================================
 
 /**
- * @brief Concept for edge descriptors
- * 
- * An edge is an edge descriptor that provides access to both source and target vertices.
- * All edge descriptors in the graph library provide these operations.
- * 
+ * @brief Concept for edge types
+ *
+ * An edge is any type for which source_id(g, e) and target_id(g, e) are valid expressions.
+ * This includes adj_list edge_descriptors, edge_list descriptors, edge_data aggregates,
+ * tuple/pair representations, and any user-defined type with appropriate CPO support.
+ *
  * Requirements:
- * - e must be an edge_descriptor
  * - source_id(g, e) must be valid (returns source vertex ID)
- * - source(g, e) must be valid (returns source vertex descriptor)
  * - target_id(g, e) must be valid (returns target vertex ID)
- * - target(g, e) must be valid (returns target vertex descriptor)
- * 
+ *
  * Note: Return types are not constrained to allow better compiler error messages.
- * 
+ * Algorithms that additionally need vertex descriptors (source(g,e) / target(g,e))
+ * should add those requirements explicitly beyond this concept.
+ *
  * Examples:
- * - Edge in adjacency list: edge_descriptor<vector<vector<int>>::iterator, int>
- * - Edge in edge list: edge_descriptor<vector<tuple<int, int, double>>::iterator>
- * - Weighted edge: edge_descriptor with value access
- * 
- * @tparam G Graph type
- * @tparam E Edge type (must be edge_descriptor)
+ * - adj_list edge_descriptor<EdgeIter, VertexIter, EdgeDirection>
+ * - edge_list edge_descriptor<VId, EV>
+ * - edge_data<VId, true, void, EV>
+ * - std::tuple<int, int, double>  (source=get<0>, target=get<1>)
+ *
+ * @tparam G Graph (or edge-list container) type
+ * @tparam E Edge type
  */
 template <class G, class E>
-concept edge = is_edge_descriptor_v<std::remove_cvref_t<E>> && requires(G& g, const E& e) {
+concept edge = requires(G& g, const E& e) {
   source_id(g, e);
-  source(g, e);
   target_id(g, e);
-  target(g, e);
 };
 
 // =============================================================================

tests/edge_list/test_edge_list_concepts.cpp

@@ -2,6 +2,7 @@
 #include <graph/edge_list/edge_list.hpp>
 #include <graph/edge_list/edge_list_descriptor.hpp>
 #include <graph/graph_data.hpp>
+#include <graph/adj_list/adjacency_list_concepts.hpp>
 #include <vector>
 #include <tuple>
 
@@ -158,3 +159,30 @@ TEST_CASE("has_edge_value runtime behavior", "[edge_list][runtime]") {
   auto val = graph::edge_value(edges, e);
   REQUIRE(val == 3.14);
 }
+
+// =============================================================================
+// Interop with adj_list::edge<G,E> concept (I.2)
+// =============================================================================
+
+TEST_CASE("edge_list types satisfy adj_list::edge concept", "[edge_list][concepts][interop]") {
+  // After dropping the is_edge_descriptor_v gate, any type whose elements
+  // support source_id(g,e) and target_id(g,e) satisfies edge<G,E>.
+
+  // tuple<source, target, value>
+  using tuple_el = std::vector<std::tuple<int, int, double>>;
+  STATIC_REQUIRE(adj_list::edge<tuple_el, std::tuple<int, int, double>>);
+
+  // pair<source, target>
+  using pair_el = std::vector<std::pair<int, int>>;
+  STATIC_REQUIRE(adj_list::edge<pair_el, std::pair<int, int>>);
+
+  // edge_data with value
+  using ed_type = graph::edge_data<int, true, void, double>;
+  using ed_el   = std::vector<ed_type>;
+  STATIC_REQUIRE(adj_list::edge<ed_el, ed_type>);
+
+  // edge_list::edge_descriptor
+  using desc_type = edge_list::edge_descriptor<int, double>;
+  using desc_el   = std::vector<desc_type>;
+  STATIC_REQUIRE(adj_list::edge<desc_el, desc_type>);
+}