maybe it will work with ID remapping

Author: SpectraL519

include/gl/graph.hpp

@@ -253,6 +253,8 @@ class graph final {
         return this->_impl.degree_map();
     }
 
+    // TODO: add a get_vertex_properties function
+
     [[nodiscard]] gl_attr_force_inline auto vertex_properties_map() const noexcept
     requires(not type_traits::is_default_properties_type_v<vertex_properties_type>)
     {

include/gl/impl/adjacency_list.hpp

@@ -75,9 +75,10 @@ class adjacency_list final {
         return specialized_impl::degree_map(*this);
     }
 
-    template <bool GetRemovedEdgeIds>
-    gl_attr_force_inline auto remove_vertex(const types::id_type vertex_id) {
-        return specialized_impl::template remove_vertex<GetRemovedEdgeIds>(*this, vertex_id);
+    std::vector<types::id_type> remove_vertex(const types::id_type vertex_id) {
+        const auto removed_edge_ids = specialized_impl::remove_vertex(*this, vertex_id);
+        // TODO: sort removed_edge_ids & align edge ids (remapping)
+        return removed_edge_ids;
     }
 
     // --- edge methods ---

include/gl/impl/adjacency_matrix.hpp

@@ -82,9 +82,10 @@ class adjacency_matrix final {
         return specialized_impl::degree_map(*this);
     }
 
-    template <bool GetRemovedEdgeIds>
-    gl_attr_force_inline auto remove_vertex(const types::id_type vertex_id) {
-        return specialized_impl::template remove_vertex<GetRemovedEdgeIds>(*this, vertex_id);
+    std::vector<types::id_type> remove_vertex(const types::id_type vertex_id) {
+        const auto removed_edge_ids = specialized_impl::remove_vertex(*this, vertex_id);
+        // TODO: sort removed_edge_ids & align edge ids (remapping)
+        return removed_edge_ids;
     }
 
     // --- edge methods ---

include/gl/impl/specialized/adjacency_list.hpp

@@ -8,8 +8,8 @@
 
 #include <algorithm>
 #include <format>
+#include <iostream>
 #include <ranges>
-#include <unordered_set>
 #include <vector>
 
 namespace gl::impl {
@@ -108,59 +108,35 @@ struct directed_adjacency_list {
         return degree_map;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id)
-    requires(GetRemovedEdgeIds)
-    {
-        std::vector<types::id_type> removed_edges;
-        removed_edges.reserve(self._list[vertex_id].size());
-        std::ranges::copy(
-            self._list[vertex_id] | std::views::transform(&edge_list_item::id),
-            std::back_inserter(removed_edges)
-        );
+    static std::vector<types::id_type> remove_vertex(
+        impl_type& self, const types::id_type vertex_id
+    ) {
+        auto removed_edges =
+            self._list[vertex_id] | std::views::transform(&edge_list_item::id)
+            | std::ranges::to<std::vector>();
 
         // remove all edges incident to the vertex
         for (types::id_type id = constants::initial_id; id < self._list.size(); ++id) {
             auto& adj_edges = self._list[id];
             if (id == vertex_id or adj_edges.empty())
                 continue;
 
-            const auto removed_subrng = std::ranges::remove_if(
-                adj_edges, [vertex_id](const auto& item) { return item.target_id == vertex_id; }
-            );
-            std::ranges::copy(
-                removed_subrng | std::views::transform(&edge_list_item::id),
-                std::back_inserter(removed_edges)
-            );
+            const auto removed_subrng =
+                std::ranges::remove_if(adj_edges, [vertex_id, &removed_edges](const auto& item) {
+                    if (item.target_id == vertex_id) {
+                        removed_edges.push_back(item.id);
+                        return true;
+                    }
+                    return false;
+                });
             adj_edges.erase(removed_subrng.begin(), removed_subrng.end());
         }
 
         // remove the list of edges incident from the vertex entirely
         self._list.erase(std::next(std::begin(self._list), vertex_id));
-
         return removed_edges;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id)
-    requires(not GetRemovedEdgeIds)
-    {
-        // remove all edges incident to the vertex
-        for (types::id_type id = constants::initial_id; id < self._list.size(); ++id) {
-            auto& adj_edges = self._list[id];
-            if (id == vertex_id or adj_edges.empty())
-                continue;
-
-            const auto removed_subrng = std::ranges::remove_if(
-                adj_edges, [vertex_id](const auto& item) { return item.target_id == vertex_id; }
-            );
-            adj_edges.erase(removed_subrng.begin(), removed_subrng.end());
-        }
-
-        // remove the list of edges incident from the vertex entirely
-        self._list.erase(std::next(std::begin(self._list), vertex_id));
-    }
-
     static gl_attr_force_inline void add_edge(
         impl_type& self, types::id_type edge_id, types::id_type source_id, types::id_type target_id
     ) {
@@ -183,6 +159,7 @@ struct directed_adjacency_list {
     static gl_attr_force_inline void remove_edge(impl_type& self, const edge_type& edge) {
         auto& adj_edges = self._list[edge.first()];
         adj_edges.erase(detail::strict_find(adj_edges, edge));
+        // TODO: align edge ids (common)
     }
 };
 
@@ -233,8 +210,9 @@ struct undirected_adjacency_list {
         return degree_map;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id) {
+    static std::vector<types::id_type> remove_vertex(
+        impl_type& self, const types::id_type vertex_id
+    ) {
         // remove all edges incident with the vertex (scan only the selected vertices)
         for (const auto& item : self._list[vertex_id]) {
             if (item.target_id == vertex_id)
@@ -248,16 +226,11 @@ struct undirected_adjacency_list {
         }
 
         // remove the list of edges incident from the vertex entirely
-        if constexpr (GetRemovedEdgeIds) {
-            const auto removed_edges =
-                self._list[vertex_id] | std::views::transform(&edge_list_item::id)
-                | std::ranges::to<std::vector>;
-            self._list.erase(std::next(std::begin(self._list), vertex_id));
-            return removed_edges;
-        }
-        else {
-            self._list.erase(std::next(std::begin(self._list), vertex_id));
-        }
+        const auto removed_edges =
+            self._list[vertex_id] | std::views::transform(&edge_list_item::id)
+            | std::ranges::to<std::vector>();
+        self._list.erase(std::next(std::begin(self._list), vertex_id));
+        return removed_edges;
     }
 
     static void add_edge(
@@ -295,6 +268,8 @@ struct undirected_adjacency_list {
             adj_edges_first.erase(detail::strict_find(adj_edges_first, edge));
             adj_edges_second.erase(detail::strict_find(adj_edges_second, edge));
         }
+
+        // TODO: align edge ids (common)
     }
 };
 

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -118,10 +118,9 @@ struct directed_adjacency_matrix {
         return degree_map;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id)
-    requires(GetRemovedEdgeIds)
-    {
+    static std::vector<types::id_type> remove_vertex(
+        impl_type& self, const types::id_type vertex_id
+    ) {
         auto removed_edges =
             self._matrix[vertex_id]
             | std::views::filter([](auto edge_id) { return edge_id != constants::invalid_id; })
@@ -138,15 +137,6 @@ struct directed_adjacency_matrix {
         return removed_edges;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id)
-    requires(not GetRemovedEdgeIds)
-    {
-        self._matrix.erase(std::next(std::begin(self._matrix), vertex_id));
-        for (auto& row : self._matrix)
-            row.erase(std::next(std::begin(row), vertex_id));
-    }
-
     static inline void add_edge(
         impl_type& self, types::id_type edge_id, types::id_type source_id, types::id_type target_id
     ) {
@@ -170,6 +160,7 @@ struct directed_adjacency_matrix {
 
     static inline void remove_edge(impl_type& self, const edge_type& edge) {
         detail::strict_get(self._matrix, edge) = constants::invalid_id;
+        // TODO: align edge ids (common)
     }
 };
 
@@ -232,22 +223,18 @@ struct undirected_adjacency_matrix {
         return degree_map;
     }
 
-    template <bool GetRemovedEdgeIds>
-    static auto remove_vertex(impl_type& self, const types::id_type vertex_id) {
+    static std::vector<types::id_type> remove_vertex(
+        impl_type& self, const types::id_type vertex_id
+    ) {
         for (auto& row : self._matrix)
             row.erase(std::next(std::begin(row), vertex_id));
 
-        if constexpr (GetRemovedEdgeIds) {
-            const auto removed_edges =
-                self._matrix[vertex_id]
-                | std::views::filter([](auto edge_id) { return edge_id != constants::invalid_id; })
-                | std::ranges::to<std::vector>;
-            self._matrix.erase(std::next(std::begin(self._matrix), vertex_id));
-            return removed_edges;
-        }
-        else {
-            self._matrix.erase(std::next(std::begin(self._matrix), vertex_id));
-        }
+        const auto removed_edges =
+            self._matrix[vertex_id]
+            | std::views::filter([](auto edge_id) { return edge_id != constants::invalid_id; })
+            | std::ranges::to<std::vector>;
+        self._matrix.erase(std::next(std::begin(self._matrix), vertex_id));
+        return removed_edges;
     }
 
     static void add_edge(
@@ -287,6 +274,8 @@ struct undirected_adjacency_matrix {
             // it will also be present in the second matrix cell
             self._matrix[edge.second()][edge.first()] = constants::invalid_id;
         }
+
+        // TODO: align edge ids (common)
     }
 };
 

tests/source/gl/test_adjacency_list.cpp

@@ -343,29 +343,7 @@ TEST_CASE_FIXTURE(
 
 TEST_CASE_FIXTURE(
     test_directed_adjacency_list,
-    "remove_vertex<GetRemovedEdgeIds=false> should remove the given vertex and all edges incident "
-    "with it"
-) {
-    init_complete_graph();
-
-    const auto removed_vertex_id = constants::first_element_idx;
-    sut.remove_vertex<false>(removed_vertex_id);
-
-    constexpr auto n_vertices_after_remove = constants::n_elements - constants::one_element;
-    constexpr auto n_incident_edges_after_remove =
-        n_incident_edges_for_fully_connected_vertex - constants::one_element;
-
-    REQUIRE_EQ(size(sut), n_vertices_after_remove);
-    for (const auto vertex_id :
-         constants::vertex_id_view | std::views::take(n_vertices_after_remove)) {
-        CHECK_EQ(sut.adjacent_edges(vertex_id).size(), n_incident_edges_after_remove);
-    }
-}
-
-TEST_CASE_FIXTURE(
-    test_directed_adjacency_list,
-    "remove_vertex<GetRemovedEdgeIds=true> should remove the given vertex and all edges incident "
-    "with it"
+    "remove_vertex should remove the given vertex and all edges incident with it"
 ) {
     const auto edge1 = add_edge(constants::vertex_id_1, constants::vertex_id_2);
     const auto edge3 = add_edge(constants::vertex_id_2, constants::vertex_id_1);
@@ -376,27 +354,19 @@ TEST_CASE_FIXTURE(
     const auto edge6 = add_edge(constants::vertex_id_3, constants::vertex_id_2);
 
     const auto removed_vertex_id = constants::vertex_id_1;
-    const auto removed_edge_ids = sut.remove_vertex<true>(removed_vertex_id);
+    const auto removed_edge_ids = sut.remove_vertex(removed_vertex_id);
 
     REQUIRE_EQ(removed_edge_ids.size(), 4uz);
     for (const auto edge_id : {edge1.id(), edge2.id(), edge3.id(), edge4.id()})
         CHECK(std::ranges::contains(removed_edge_ids, edge_id));
     for (const auto edge_id : {edge5.id(), edge6.id()})
         CHECK_FALSE(std::ranges::contains(removed_edge_ids, edge_id));
 
-    constexpr auto n_vertices_after_remove = constants::n_elements - constants::one_element;
-    constexpr auto n_incident_edges_after_remove =
-        n_incident_edges_for_fully_connected_vertex - constants::one_element;
-
-    REQUIRE_EQ(size(sut), n_vertices_after_remove);
-    for (const auto vertex_id :
-         constants::vertex_id_view | std::views::take(n_vertices_after_remove)) {
-        CHECK_EQ(sut.adjacent_edges(vertex_id).size(), n_incident_edges_after_remove);
-    }
+    CHECK_EQ(size(sut), constants::n_elements - 1uz);
+    CHECK_EQ(sut.adjacent_edges(constants::vertex_id_1).size(), 1uz); // IDs were aligned
+    CHECK_EQ(sut.adjacent_edges(constants::vertex_id_2).size(), 1uz); // IDs were aligned
 }
 
-// TODO: add test case with GetRemovedEdgeIds=true
-
 struct test_undirected_adjacency_list : public test_adjacency_list {
     using edge_type = gl::undirected_edge<>;
     using sut_type = gl::impl::adjacency_list<gl::list_graph_traits<gl::undirected_t>>;
@@ -670,20 +640,24 @@ TEST_CASE_FIXTURE(
     test_undirected_adjacency_list,
     "remove_vertex should remove the given vertex and all edges incident with it"
 ) {
-    init_complete_graph();
+    const auto edge1 = add_edge(constants::vertex_id_1, constants::vertex_id_2);
+    const auto edge3 = add_edge(constants::vertex_id_2, constants::vertex_id_1);
+    const auto edge2 = add_edge(constants::vertex_id_1, constants::vertex_id_3);
+    const auto edge4 = add_edge(constants::vertex_id_3, constants::vertex_id_1);
+
+    const auto edge5 = add_edge(constants::vertex_id_2, constants::vertex_id_3);
 
     const auto removed_vertex_id = constants::first_element_idx;
-    sut.remove_vertex<false>(removed_vertex_id);
+    const auto removed_edge_ids = sut.remove_vertex(removed_vertex_id);
 
-    constexpr auto n_vertices_after_remove = constants::n_elements - constants::one_element;
-    constexpr auto n_incident_edges_after_remove =
-        n_incident_edges_for_fully_connected_vertex - constants::one_element;
+    REQUIRE_EQ(removed_edge_ids.size(), 4uz);
+    for (const auto edge_id : {edge1.id(), edge2.id(), edge3.id(), edge4.id()})
+        CHECK(std::ranges::contains(removed_edge_ids, edge_id));
+    CHECK_FALSE(std::ranges::contains(removed_edge_ids, edge5.id()));
 
-    REQUIRE_EQ(size(sut), n_vertices_after_remove);
-    for (const auto vertex_id :
-         constants::vertex_id_view | std::views::take(n_vertices_after_remove)) {
-        CHECK_EQ(sut.adjacent_edges(vertex_id).size(), n_incident_edges_after_remove);
-    }
+    CHECK_EQ(size(sut), constants::n_elements - 1uz);
+    CHECK_EQ(sut.adjacent_edges(constants::vertex_id_1).size(), 1uz); // IDs were aligned
+    CHECK_EQ(sut.adjacent_edges(constants::vertex_id_2).size(), 1uz); // IDs were aligned
 }
 
 TEST_SUITE_END(); // test_adjacency_list