added test, improve implementaion

Author: tonibohnlein

include/osp/graph_algorithms/directed_graph_edge_view.hpp

@@ -83,35 +83,29 @@ class edge_view {
 
         DirectedEdgeIterator(const vertex_idx_t<Graph_t> edge_idx, const Graph_t &graph)
             : graph_(&graph), currentVertex_(0), currentEdgeIdx_(edge_idx) {
-            if (currentEdgeIdx_ < graph_->num_edges()) {
-                vertex_idx_t<Graph_t> tmp = 0u;
-                advanceToValid();
 
-                while (currentVertex_ != graph_->num_vertices() && tmp < currentEdgeIdx_) {
-                    while (currentChild_ != graph_->children(currentVertex_).end()) {
-                        if (tmp == currentEdgeIdx_) {
-                            return;
-                        }
-                        currentChild_++;
-                        tmp++;
-                    }
-                    // Move to next vertex
-                    currentVertex_++;
-                    if (currentVertex_ != graph_->num_vertices()) {
-                        currentChild_ = graph_->children(currentVertex_).begin();
-                        // Skip empty adjacency lists
-                        while (currentVertex_ != graph_->num_vertices() &&
-                               graph_->children(currentVertex_).begin() == graph_->children(currentVertex_).end()) {
-                            currentVertex_++;
-                            if (currentVertex_ != graph_->num_vertices()) {
-                                currentChild_ = graph_->children(currentVertex_).begin();
-                            }
-                        }
-                    }
-                }
-            } else {
+            if (currentEdgeIdx_ >= graph_->num_edges()) {
                 currentEdgeIdx_ = graph_->num_edges();
                 currentVertex_ = graph_->num_vertices();
+                return;
+            }
+
+            vertex_idx_t<Graph_t> currentAccumulatedEdges = 0;
+
+            // Optimization: Skip vertices entirely if their degree is small enough
+            while (currentVertex_ < graph_->num_vertices()) {
+                const auto degree = graph_->out_degree(currentVertex_);
+                if (currentAccumulatedEdges + degree > currentEdgeIdx_) {
+                    break;
+                }
+                currentAccumulatedEdges += degree;
+                currentVertex_++;
+            }
+
+            // Initialize child iterator and advance within the specific vertex
+            if (currentVertex_ < graph_->num_vertices()) {
+                currentChild_ = graph_->children(currentVertex_).begin();
+                std::advance(currentChild_, currentEdgeIdx_ - currentAccumulatedEdges);
             }
         }
 
@@ -124,14 +118,7 @@ class edge_view {
 
             if (currentChild_ == graph_->children(currentVertex_).end()) {
                 currentVertex_++;
-                // Skip empty vertices
-                while (currentVertex_ != graph_->num_vertices()) {
-                    if (graph_->children(currentVertex_).begin() != graph_->children(currentVertex_).end()) {
-                        currentChild_ = graph_->children(currentVertex_).begin();
-                        break;
-                    }
-                    currentVertex_++;
-                }
+                advanceToValid();
             }
             return *this;
         }

tests/directed_graph_util.cpp

@@ -602,7 +602,13 @@ BOOST_AUTO_TEST_CASE(ComputationalDagConstructor) {
     BOOST_CHECK(get_bottom_node_distance(graph) == bottom_dist);
 
     const std::vector<std::vector<VertexType>> graph_second_Out = {
-        {1, 2}, {3, 4}, {4, 5}, {6}, {}, {6}, {},
+        {1, 2},
+        {3, 4},
+        {4, 5},
+        {6},
+        {},
+        {6},
+        {},
     };
     const std::vector<int> graph_second_workW = {1, 1, 1, 1, 1, 1, 3};
     const std::vector<int> graph_second_commW = graph_second_workW;
@@ -675,4 +681,30 @@ BOOST_AUTO_TEST_CASE(ComputationalDagConstructor) {
     //         rev_edge_in_rev_graph);
     //     }
     // }
+}
+
+BOOST_AUTO_TEST_CASE(test_edge_view_indexed_access) {
+    computational_dag_vector_impl_def_t graph = constr_graph_1();
+    auto all_edges = edge_view(graph);
+
+    // Check initial iterator
+    auto it = all_edges.begin();
+
+    // Check each edge by index
+    for (size_t i = 0; i < graph.num_edges(); ++i) {
+        // Construct iterator directly to index i
+        auto indexed_it = decltype(all_edges)::iterator(i, graph);
+        BOOST_CHECK(indexed_it == it);
+        BOOST_CHECK(*indexed_it == *it);
+
+        ++it;
+    }
+
+    // Check end condition
+    auto end_it = decltype(all_edges)::iterator(graph.num_edges(), graph);
+    BOOST_CHECK(end_it == all_edges.end());
+
+    // Check out of bounds
+    auto oob_it = decltype(all_edges)::iterator(graph.num_edges() + 5, graph);
+    BOOST_CHECK(oob_it == all_edges.end());
 }