Feature/views implementation

CMakeLists.txt

@@ -19,6 +19,7 @@ include(Sanitizers)
 include(CodeCoverage)
 include(CompilerCache)
 include(PrecompiledHeaders)
+include(CPM)
 
 # C++ standard
 set(CMAKE_CXX_STANDARD 20)
@@ -56,6 +57,9 @@ target_include_directories(graph3 INTERFACE
 
 target_compile_features(graph3 INTERFACE cxx_std_20)
 
+# Link tl::expected for optional cycle detection in topological sort
+target_link_libraries(graph3 INTERFACE tl::expected)
+
 # Apply compiler warnings
 set_project_warnings(graph3)
 

agents/edge_list_goal.md

@@ -2,36 +2,39 @@
 
 The abstract edge list, a complement to the abstract adjacency list, needs to be implemented.
 
-An edge list is a container or range of edge values that can be projected to the `edge_info` 
-data structure defined in `graph_info.hpp`. This provides an alternative graph representation 
-focused on edges rather than vertices. 
-
-There are multiple (and subtle forms) of edge list, as follows:
-- "edge list" with a space between the words refers to the abstract edge list data structure.
-- The "edge_list" namespace (with an underscore) is the namespace for the abstract edge list
-  implementation.
-- "edgelist" (one word) refers to the edgelist view used by the abstract adjacency list data structure.
+An edge list is a range of edge values that have a target_id, source_id and optional edge_value.
+This can be represented by projecting values on into an `edge_info` data structure defined in 
+`graph_info.hpp`. This is an example, and other methods should be considered to implement it.
+
+## Edge Lists Types and Naming
+The term edge list has different forms.
+- The abstract edge list is a range of values with a `target_id`, `source_id` and optional 
+  `edge_value` members. They can have different names, so the library needs to be able to 
+  enable the user to expose them into those names using the matching CPO functions. `edge_list`
+  (with an underscore separator) will be used to refer to this.
+- `edgelist` (one word) refers to an edge list view of all edges in an adjacency list. This has
+  not been implemented yet.
 
 ## Goals
 Create an implementation for an edge list in the `graph::edge_list` namespace, a peer to 
 `graph::adj_list`. 
 
-In the future, there will be an edgelist view that iterates through all outgoing edges of 
-all vertices that will also project `edge_info` values. This will allow algorithms to work 
-equally well against either:
-- The abstract edge list data structure, or
-- All edges in an abstract adjacency list (via the edgelist view)
+Future algorithms that require an edge list must be able to work with either an `edge_list`
+or an `edgelist` view without caring which one it is using.
 
-## Important Details
+CPOs for `source_id(g,uv)`, `target_id(g,uv)` and `edge_value(g,uv)` need to work on an adjacency list
+edge, a `edge_list` value, and an `edgelist` view. This will help unify the overall design. Observations 
+to consider for implementation:
+- Extend the `source_id(g,uv)`, `target_id(g,uv)` and `edge_value(g,uv)` CPOs to handle the `edge_list` values.
+- Extend the edge descriptor to handle the `edge_list` values.
+
+## Reference Implementation
 `/mnt/d/dev_graph/graph-v2` contains an earlier version of this library (graph-v2) that uses
 a reference-based define instead of the value-based descriptors. It has a similar directory
-layout, including the `edge_list/` directory for the edge list implementation that can be used 
-as a reference. I don't think our edge list implementation needs descriptors, so the reference
-implementation may be able to be copied with little change.
-
-The adjacency list views for an edge list will be named `edgelist` in order to distinguish from the
-abstract edge list data structure in the `edge_list` namespace.
+layout, including the `edge_list/` subdirectory for the edge list implementation that can be used 
+as a reference design. The implementation for this library may need to be different.
 
+## Important Details
 `graph_info.hpp` contains common definitions of classes/structs that are shared between both the 
 adjacency list and edge list data structures. While `edge_info` is the primary shared type, others 
 could be added in the future.