GraphNode

Documentation

API Reference

GraphNode

Description

Opaque node handle used by traversal helpers.

This carries the owning graph pointer plus the stable node id. Users typically obtain it from GraphGetNode, GraphForeachNode, or GraphNodeForeachNeighbor.

The handle is meant for active traversal and graph-aware node access. Long-lived external state should usually be stored separately, keyed by GraphNodeGetId(node) or by application data held in the node payload.

Usage example (Cross-references)

Usage examples (Cross-references)

In Graph.c:119:

    }
    
    static GraphNode graph_validate_node_handle(GraphNode node) {
        GenericGraph *graph;

In Graph.c:623:

    }
    
    GraphNode graph_get_node(GenericGraph *graph, GraphNodeId node_id) {
        GraphNode node;

In Graph.c:624:

    
    GraphNode graph_get_node(GenericGraph *graph, GraphNodeId node_id) {
        GraphNode node;
    
        ValidateGraph(graph);

In Graph.c:638:

    }
    
    void *graph_node_data_ptr_checked(GenericGraph *graph, GraphNode node) {
        GraphNode validated = graph_validate_node_handle(node);

In Graph.c:639:

    
    void *graph_node_data_ptr_checked(GenericGraph *graph, GraphNode node) {
        GraphNode validated = graph_validate_node_handle(node);
    
        if (GENERIC_GRAPH(validated.__graph) != graph) {

In Graph.c:724:

    }
    
    u64 graph_node_visit(GraphNode node) {
        GenericGraph     *graph;
        GenericGraphSlot *slot;

In Graph.c:740:

    }
    
    void graph_node_unvisit(GraphNode node) {
        GenericGraph     *graph;
        GenericGraphSlot *slot;

In Graph.c:751:

    }
    
    u64 graph_node_visit_count(GraphNode node) {
        GenericGraph           *graph;
        const GenericGraphSlot *slot;

In Graph.c:761:

    }
    
    bool graph_node_visited(GraphNode node) {
        return graph_node_visit_count(node) > 0;
    }

In Graph.c:765:

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

In Graph.c:782:

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

In Graph.c:793:

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

In Graph.c:926:

    }
    
    bool graph_node_iter_next(GenericGraphNodeIter *iter, GraphNode *out_node) {
        if (!iter || !out_node) {
            LOG_FATAL("invalid arguments");

In Graph.c:955:

    }
    
    GenericGraphNeighborIter graph_neighbor_iter_begin(GraphNode node) {
        GenericGraphNeighborIter iter;
        GenericGraph            *graph;

In Graph.c:969:

    }
    
    bool graph_neighbor_iter_next(GenericGraphNeighborIter *iter, GraphNode *out_node) {
        GraphNeighbors *neighbors;

In Graph.c:1002:

    }
    
    GenericGraphPredecessorIter graph_predecessor_iter_begin(GraphNode node) {
        GenericGraphPredecessorIter iter;
        GenericGraph               *graph;

In Graph.c:1016:

    }
    
    bool graph_predecessor_iter_next(GenericGraphPredecessorIter *iter, GraphNode *out_node) {
        GraphNeighbors *neighbors;

In Graph.Foreach.c:64:

    }
    
    static bool city_reachable_from(GraphNode node, GraphNodeId goal_id) {
        if (GraphNodeVisitCount(node) > 0) {
            return false;

In Graph.Ops.c:13:

    
        GraphNodeId a    = GraphAddNodeR(&graph, 10);
        GraphNode   node = GraphGetNode(&graph, a);
    
        bool result = !GraphNodeVisited(node) && (GraphNodeVisitCount(node) == 0);

In Graph.Ops.c:80:

    
        GraphNodeId a    = GraphAddNodeR(&graph, 10);
        GraphNode   node = GraphGetNode(&graph, a);
    
        bool result = !GraphNodeMarkedForDeletion(node);

In Graph.Ops.c:289:

    
    static bool test_graph_stale_node_handle_after_commit_deadend(void) {
        WriteFmt("Testing stale GraphNode handle after commit (should abort)\n");
    
        typedef Graph(int) IntGraph;

In Graph.Ops.c:295:

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

In Graph.Init.c:68:

        Str        name  = StrInitFromZstr("alpha");
        GraphNodeId node_id;
        GraphNode   node;
        Str        *stored_name;

In Graph.Type.c:31:

    
        GraphNodeId node_id = GraphAddNodeR(&graph, 11);
        GraphNode   node    = GraphGetNode(&graph, node_id);
    
        bool result = graph.alignment == 32 && GraphNodeIdIndex(node_id) == 0 && GraphNodeIdGeneration(node_id) == 1;

In Graph.Access.c:15:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);
        GraphNode   node_b;
        GraphAddEdge(&graph, a, b);
        GraphAddEdge(&graph, a, c);

In Graph.Access.c:74:

        IntGraph graph_a = GraphInit();
        IntGraph graph_b = GraphInit();
        GraphNode node   = GraphGetNode(&graph_a, GraphAddNodeR(&graph_a, 10));
    
        (void)GraphNodeData(&graph_b, node);

In Foreach.h:35:

                for (GenericGraphNodeIter UNPL(iter) = graph_node_iter_begin(GENERIC_GRAPH(UNPL(pg))); UNPL(iter).graph;  \
                     UNPL(iter).graph = NULL)                                                                              \
                    for (GraphNode node = {0}; graph_node_iter_next(&UNPL(iter), &node);)
    
    ///

In Foreach.h:49:

    ///
    #define GraphNodeForeachNeighbor(node, neighbor)                                                                       \
        for (GraphNode UNPL(src_node) = (node); UNPL(src_node).__graph; UNPL(src_node).__graph = NULL)                    \
            for (GenericGraphNeighborIter UNPL(iter) = graph_neighbor_iter_begin(UNPL(src_node)); UNPL(iter).graph;       \
                 UNPL(iter).graph = NULL)                                                                                  \

In Foreach.h:52:

            for (GenericGraphNeighborIter UNPL(iter) = graph_neighbor_iter_begin(UNPL(src_node)); UNPL(iter).graph;       \
                 UNPL(iter).graph = NULL)                                                                                  \
                for (GraphNode neighbor = {0}; graph_neighbor_iter_next(&UNPL(iter), &neighbor);)
    
    ///

In Foreach.h:66:

    ///
    #define GraphNodeForeachPredecessor(node, predecessor)                                                                \
        for (GraphNode UNPL(dst_node) = (node); UNPL(dst_node).__graph; UNPL(dst_node).__graph = NULL)                   \
            for (GenericGraphPredecessorIter UNPL(iter) = graph_predecessor_iter_begin(UNPL(dst_node));                  \
                 UNPL(iter).graph;                                                                                        \

In Foreach.h:70:

                 UNPL(iter).graph;                                                                                        \
                 UNPL(iter).graph = NULL)                                                                                 \
                for (GraphNode predecessor = {0}; graph_predecessor_iter_next(&UNPL(iter), &predecessor);)
    
    #endif // MISRA_STD_CONTAINER_GRAPH_FOREACH_H

In Type.h:66:

        void       *__graph;
        GraphNodeId __id;
    } GraphNode;
    
    ///

Last updated on April 28, 2026

GraphNeighbors GraphNodeAt