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:98:

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

In Graph.c:646:

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

In Graph.c:647:

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

In Graph.c:661:

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

In Graph.c:662:

    
    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:764:

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

In Graph.c:780:

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

In Graph.c:791:

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

In Graph.c:801:

    }
    
    bool GraphNodeVisited(GraphNode node) {
        return GraphNodeVisitCount(node) > 0;
    }

In Graph.c:805:

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

In Graph.c:822:

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

In Graph.c:833:

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

In Graph.c:964:

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

In Graph.c:993:

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

In Graph.c:1007:

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

In Graph.c:1040:

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

In Graph.c:1054:

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

In Graph.Access.c:19:

        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:84:

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

In Graph.Type.c:43:

    
        GraphNodeId node_id = GraphAddNodeR(&graph, 11);
        GraphNode   node    = GraphGetNode(&graph, node_id);
    
        bool result = GraphAllocator(&graph)->alignment == 32 && GraphNodeIdIndex(node_id) == 0 &&

In Graph.Ops.c:16:

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

In Graph.Ops.c:89:

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

In Graph.Ops.c:317:

    
    static bool test_graph_stale_node_handle_after_commit_deadend(void) {
        WriteFmt("Testing stale GraphNode handle after commit (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

In Graph.Ops.c:325:

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

In Graph.Init.c:82:

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

In Graph.Init.c:106:

        StrGraph    graph = GraphInitWithDeepCopy(NULL, str_deinit, &alloc);
        GraphNodeId node_id;
        GraphNode   node;
        Str        *stored_name;

In Graph.Foreach.c:46:

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

In Ops.h:32:

        /// TAGS: Graph, Node, Visit, Mutation
        ///
        u64 GraphNodeVisit(GraphNode node);
    
        ///

In Ops.h:46:

        /// TAGS: Graph, Node, Visit, Reset
        ///
        void GraphNodeUnvisit(GraphNode node);
    
        ///

In Ops.h:65:

        /// TAGS: Graph, Node, Delete, Mark
        ///
        bool GraphMarkNodeForDeletion(GraphNode node);
    
        ///

In Ops.h:79:

        /// TAGS: Graph, Node, Delete, Query
        ///
        bool GraphNodeMarkedForDeletion(GraphNode node);
    
        ///

In Ops.h:94:

        /// TAGS: Graph, Node, Delete, Unmark
        ///
        bool GraphUnmarkNodeForDeletion(GraphNode node);
    
    #ifdef __cplusplus

In Access.h:319:

        /// TAGS: Graph, Node, Visit, Count, Query
        ///
        u64 GraphNodeVisitCount(GraphNode node);
    
        ///

In Access.h:331:

        /// TAGS: Graph, Node, Visit, Query
        ///
        bool GraphNodeVisited(GraphNode node);
    
    #ifdef __cplusplus

In Foreach.h:39:

                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:57:

    ///
    #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:60:

            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:78:

    ///
    #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:82:

                 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 June 10, 2026

GraphNeighbors GraphNodeAt