GraphMarkNodeForDeletion

Documentation

API Reference

Description

Mark a node for deletion on the next GraphCommitChanges.

Marked nodes remain visible until commit. This operation is safe during graph traversal and is intended for destructive passes that need stable iteration.

Parameters

Name	Direction	Description
`node`	in	`GraphNode` handle to mark.

Success

Returns true. The slot referenced by node is now flagged as marked; the graph’s pending-delete count grows by one. live_count is unchanged - the node is still observable through traversal and lookup until GraphCommitChanges runs.

Failure

Returns false when the node was already marked. The graph is not modified.

Usage example (Cross-references)

Usage examples (Cross-references)

In Graph.c:805:

    }
    
    bool GraphMarkNodeForDeletion(GraphNode node) {
        GenericGraph     *graph;
        GenericGraphSlot *slot;

In Ops.c:34:

    
    static bool test_graph_mark_delete_commit_and_reuse(void) {
        WriteFmt("Testing GraphMarkNodeForDeletion and GraphCommitChanges\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Ops.c:51:

        GraphForeachNode(&graph, node) {
            if (GraphNodeData(&graph, node) == 20) {
                GraphMarkNodeForDeletion(node);
            }
        }

In Ops.c:92:

    
        bool result = !GraphNodeMarkedForDeletion(node);
        result      = result && GraphMarkNodeForDeletion(node);
        result      = result && GraphNodeMarkedForDeletion(node);
        result      = result && !GraphMarkNodeForDeletion(node);

In Ops.c:94:

        result      = result && GraphMarkNodeForDeletion(node);
        result      = result && GraphNodeMarkedForDeletion(node);
        result      = result && !GraphMarkNodeForDeletion(node);
        result      = result && GraphUnmarkNodeForDeletion(node);
        result      = result && !GraphNodeMarkedForDeletion(node);

In Ops.c:263:

    
        bool result = GraphMarkEdgeForRemoval(&graph, a, b);
        result      = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && GraphEdgeMarkedForRemoval(&graph, a, b);
        result      = result && GraphNodeMarkedForDeletion(GraphGetNode(&graph, b));

In Ops.c:296:

        counts[GraphNodeIdIndex(b)] = 29;
    
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && !GraphContainsNode(&graph, b);

In Ops.c:327:

        GraphNode   node = GraphGetNode(&graph, a);
    
        (void)GraphMarkNodeForDeletion(node);
        (void)GraphCommitChanges(&graph);
        (void)GraphNodeVisit(node);

In Ops.c:362:

        GraphAddEdge(&graph, a, b);
    
        GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
    
        u64 committed = GraphCommitChanges(&graph);

In Ops.c:398:

    
        // Delete b so its slot is free at the time GraphClear walks it.
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);
        result      = result && !GraphContainsNode(&graph, b);

In Ops.c:434:

    
        // One deletion leaves a single entry in free_indices going into clear.
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);

In Ops.c:470:

    
        // First commit frees b's slot (free-list entry, generation bumped).
        bool result  = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        u64  removed = GraphCommitChanges(&graph);
        result       = result && (removed == 1);

In Ops.c:477:

        // Second commit: a free slot (b's) is present. The marked/unmarked passes
        // iterate every slot; the free slot must be skipped, not validated.
        result  = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        removed = GraphCommitChanges(&graph);

In Ops.c:506:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot, a is now stale

In Ops.c:530:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse b's slot, b is now stale

In Ops.c:556:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot, a is now stale

In Ops.c:580:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse b's slot, b is now stale

In Ops.c:685:

        // Mark a (index 0, in range after the shrink) so the commit has a node to
        // delete (pending_delete_count > 0, so it does not early-return).
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
    
        // Clear the memoized validated bit on a consistent graph so commit's entry

In Ops.c:739:

        // Mark both a (in range after the shrink) and c (the slot we hide at
        // index == len). pending_delete_count = 2 so commit does real work.
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, c));

In Ops.c:740:

        // index == len). pending_delete_count = 2 so commit does real work.
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, c));
    
        // Clear the memoized validated bit on a consistent graph.

In Init.c:42:

        result = result && GraphAddEdge(&graph, third_id, third_id);
        result = result && (GraphNodeVisit(GraphGetNode(&graph, first_id)) == 1);
        result = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, second_id));
        result = result && GraphMarkEdgeForRemoval(&graph, third_id, third_id);

In Insert.c:156:

        (void)a;
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Insert.c:187:

        (void)a;
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Insert.c:223:

        GraphNodeId c = GraphAddNodeR(&graph, 30);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Insert.c:304:

    
        // Delete + commit b so its slot lands on the free list (reuse target).
        bool result = GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        result      = result && (GraphCommitChanges(&graph) == 1);

In Type.c:82:

        (void)a;
    
        GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
    
        // A structural mutation that keeps b marked but re-arms the deep

In Type.c:376:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Type.c:406:

        (void)a; // a keeps slot 0 occupied; only b is deleted to seed free_indices.
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Type.c:436:

        GraphNodeId c = GraphAddNodeR(&graph, 30);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, c));
        (void)GraphCommitChanges(&graph);

In Type.c:437:

    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, c));
        (void)GraphCommitChanges(&graph);

In Foreach.c:337:

        // Delete the middle node so its slot becomes a free hole between two
        // live slots, then commit so the deletion materializes.
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
        (void)GraphCommitChanges(&graph);

In Foreach.c:449:

        // id is stale (slot occupied, generation superseded).
        GraphNode stale = GraphGetNode(&graph, a);
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        (void)GraphAddNodeR(&graph, 99); // reuse a's slot at a higher generation

In Foreach.c:555:

            // Mark + commit a deletion mid-iteration. The commit bumps the
            // mutation epoch, so the iterator's next step must abort.
            (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, b));
            (void)GraphCommitChanges(&graph);
        }

In Access.c:204:

        // Delete + commit: slot 0 becomes free and its generation is bumped to
        // GraphNodeIdGeneration(a) + 1.
        result = result && GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        result = result && (GraphCommitChanges(&graph) == 1);
        result = result && !GraphContainsNode(&graph, a);

In Access.c:268:

        GraphNodeId a = GraphAddNodeR(&graph, 10);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);

In Access.c:317:

        GraphNodeId a = GraphAddNodeR(&graph, 10);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);
        // Reuse a's slot at a higher generation; `a` is now stale.

In Access.c:349:

        GraphNodeId a = GraphAddNodeR(&graph, 10);
    
        (void)GraphMarkNodeForDeletion(GraphGetNode(&graph, a));
        (void)GraphCommitChanges(&graph);

Last updated on July 1, 2026

GraphMarkEdgeForRemoval GraphMustAddEdge