Merge pull request #149 from Mik1810/codex/remove-nodes-from-api

Remove nodes from api

Author: Mik1810

CHANGELOG.md

@@ -4,6 +4,12 @@ This project starts explicit release versioning with `0.4.1`. Older entries belo
 
 Repository releases follow the compatibility policy in [`VERSIONING.md`](VERSIONING.md).
 
+## [1.3.41] - 2026-05-07
+
+- Closed `#125` by adding `Graph::remove_nodes_from(...)` for batched node removal with a single vertex-map rebuild.
+- Preserved `remove_node(...)`'s missing-node error policy, ignored duplicate IDs in the batch, and covered mixed existing/missing inputs.
+- Optimized incident edge-attribute cleanup to scan only edges incident to the removed vertex.
+
 ## [1.3.40] - 2026-05-07
 
 - Closed `#95` by marking pure-query graph and result accessors as `[[nodiscard]]`.

RELEASE_NOTES.md

@@ -3,6 +3,18 @@
 These notes are written for GitHub releases and can be more narrative than the
 version entries in `CHANGELOG.md`.
 
+## [1.3.41]
+
+### Highlights
+
+- Closed `#125` by adding `Graph::remove_nodes_from(...)` for batched node
+  removal.
+- The new API validates the full input first, follows `remove_node(...)`'s
+  missing-node error policy, ignores duplicate IDs, and rebuilds wrapper-side
+  vertex maps once after the batch.
+- Incident edge-attribute cleanup now scans the removed vertex's incident edges
+  instead of the whole graph.
+
 ## [1.3.40]
 
 ### Highlights

include/nxpp/graph.hpp

@@ -505,6 +505,15 @@ class Graph {
         return v;
     }
 
+    std::optional<VertexDesc> find_vertex_by_id(const NodeID& id) const {
+        for (auto [v, vend] = boost::vertices(g); v != vend; ++v) {
+            if (boost::get(vertex_name_map, *v) == id) {
+                return *v;
+            }
+        }
+        return std::nullopt;
+    }
+
     std::size_t get_edge_id(EdgeDesc e) const {
         return boost::get(edge_id_map, e);
     }
@@ -549,9 +558,14 @@ class Graph {
 
     void erase_incident_edge_properties(VertexDesc v) {
         std::vector<std::size_t> edge_ids;
-        for (auto [e, eend] = boost::edges(g); e != eend; ++e) {
-            if (boost::source(*e, g) == v || boost::target(*e, g) == v) {
-                edge_ids.push_back(get_edge_id(*e));
+        for (auto [e, eend] = boost::out_edges(v, g); e != eend; ++e) {
+            edge_ids.push_back(get_edge_id(*e));
+        }
+        if constexpr (Directed) {
+            for (auto [e, eend] = boost::in_edges(v, g); e != eend; ++e) {
+                if (boost::source(*e, g) != v) {
+                    edge_ids.push_back(get_edge_id(*e));
+                }
             }
         }
         for (auto edge_id : edge_ids) {
@@ -1004,8 +1018,8 @@ class Graph {
      * state, erases the vertex, and rebuilds the internal `NodeID` to
      * descriptor and vertex-index maps. Calling this in a tight loop over many
      * node removals can add up to roughly O(V^2 + V*E) total work. Prefer
-     * building a filtered copy of the graph when you need to drop many
-     * vertices at once, or use `clear()` to reset a graph entirely.
+     * remove_nodes_from() when you need to drop many vertices at once, or use
+     * `clear()` to reset a graph entirely.
      *
      * @throws std::runtime_error If the node is not present.
      */
@@ -1025,6 +1039,52 @@ class Graph {
         rebuild_vertex_maps();
     }
 
+    /**
+     * @brief Removes a batch of nodes and all of their incident edges.
+     *
+     * Duplicate node IDs in the input are ignored after the first occurrence.
+     * Missing node IDs follow remove_node()'s error policy: the call throws
+     * before mutating the graph if any requested node is absent.
+     *
+     * This rebuilds wrapper-side vertex maps once after the full batch.
+     *
+     * @throws std::runtime_error If any requested node is not present.
+     */
+    void remove_nodes_from(const std::vector<NodeID>& nodes) {
+        std::vector<NodeID> unique_nodes;
+        std::set<NodeID> seen;
+        for (const auto& node : nodes) {
+            if (seen.insert(node).second) {
+                unique_nodes.push_back(node);
+            }
+        }
+
+        for (const auto& node : unique_nodes) {
+            if (!has_node(node)) {
+                throw std::runtime_error("Node lookup failed: node not found.");
+            }
+        }
+
+        if (unique_nodes.empty()) {
+            return;
+        }
+
+        invalidate_min_cost_flow_state();
+        for (const auto& node : unique_nodes) {
+            auto vertex = find_vertex_by_id(node);
+            if (!vertex.has_value()) {
+                continue;
+            }
+
+            erase_incident_edge_properties(*vertex);
+            boost::clear_vertex(*vertex, g);
+            boost::remove_vertex(*vertex, g);
+            node_properties.erase(node);
+        }
+
+        rebuild_vertex_maps();
+    }
+
     /**
      * @brief Returns the outgoing neighbors of a node.
      *

tests/test_remove_node.cpp

@@ -107,12 +107,47 @@ void test_remove_node_in_multigraph_cleans_incident_edge_ids_only() {
            "remaining multigraph edge ids should still resolve to the right endpoints");
 }
 
+void test_remove_nodes_from_removes_batch_and_ignores_duplicates() {
+    nxpp::DiGraph graph;
+    graph.add_edge("A", "B", 1.0, {{"label", "ab"}});
+    graph.add_edge("B", "C", 2.0, {{"label", "bc"}});
+    graph.add_edge("C", "D", 3.0, {{"label", "cd"}});
+    graph.node("B")["kind"] = "middle";
+
+    graph.remove_nodes_from({"B", "C", "B"});
+
+    expect(!graph.has_node("B") && !graph.has_node("C"), "batch removal should remove each requested node once");
+    expect(graph.has_node("A") && graph.has_node("D"), "batch removal should keep non-requested nodes");
+    expect(graph.edges().empty(), "batch removal should remove incident edges for all requested nodes");
+    expect(!graph.has_node_attr("B", "kind"), "batch removal should clean node attributes");
+    expect(!graph.has_edge_attr("A", "B", "label"), "batch removal should clean incident edge attributes");
+    expect(!graph.has_edge_attr("C", "D", "label"), "batch removal should clean incident edge attributes");
+}
+
+void test_remove_nodes_from_missing_node_throws_without_mutating() {
+    nxpp::DiGraph graph;
+    graph.add_edge("A", "B", 1.0);
+    graph.add_edge("B", "C", 2.0);
+
+    expect_runtime_error_message(
+        [&graph] { graph.remove_nodes_from({"B", "missing"}); },
+        "Node lookup failed: node not found.",
+        "remove_nodes_from should reject any missing node"
+    );
+
+    expect(graph.has_node("A") && graph.has_node("B") && graph.has_node("C"),
+           "failed batch removal should leave nodes unchanged");
+    expect(graph.edges().size() == 2, "failed batch removal should leave edges unchanged");
+}
+
 int main() {
     return run_tests({
         {"remove middle node updates nodes and edges", test_remove_middle_node_updates_nodes_and_edges},
         {"remove_node cleans node and incident edge attributes", test_remove_node_cleans_node_and_incident_edge_attributes},
         {"algorithms still work after descriptor remap", test_algorithms_still_work_after_descriptor_remap},
         {"remove_node updates component views", test_remove_node_updates_component_views},
         {"remove_node in multigraph cleans incident edge ids only", test_remove_node_in_multigraph_cleans_incident_edge_ids_only},
+        {"remove_nodes_from removes batch and ignores duplicates", test_remove_nodes_from_removes_batch_and_ignores_duplicates},
+        {"remove_nodes_from missing node throws without mutating", test_remove_nodes_from_missing_node_throws_without_mutating},
     });
 }