GraphNodeId

Documentation

API Reference

GraphNodeId

Description

Stable identifier used to refer to a graph node.

Node ids are opaque 64-bit values. Internally they pack a per-slot generation in the high 32 bits and a slot index in the low 32 bits.

A node id is stable only while that node remains live. After GraphCommitChanges deletes a node, any old id or handle referring to that slot becomes stale and must not be used with live-node access APIs.

Usage example (Cross-references)

Usage examples (Cross-references)

In Graph.c:19:

    #define MISRA_GRAPH_SLOT_MARKED   ((u32)1u << 1)
    
    static GraphNodeId graph_make_node_id(u32 index, u32 generation) {
        return (((u64)generation) << 32) | (u64)index;
    }

In Graph.c:85:

    }
    
    static void graph_validate_node_id(const GenericGraph *graph, GraphNodeId node_id) {
        u32                     index;
        u32                     generation;

In Graph.c:109:

    }
    
    static GenericGraphSlot *graph_require_live_slot(GenericGraph *graph, GraphNodeId node_id) {
        graph_validate_node_id(graph, node_id);
        return graph_slot_ptr_raw(graph, GraphNodeIdIndex(node_id));

In Graph.c:114:

    }
    
    static const GenericGraphSlot *graph_require_live_slot_const(const GenericGraph *graph, GraphNodeId node_id) {
        graph_validate_node_id(graph, node_id);
        return graph_slot_ptr_const_raw(graph, GraphNodeIdIndex(node_id));

In Graph.c:203:

        slot->data = NULL;
    
        deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
        slot->out_neighbors = VecInitT(slot->out_neighbors);
        deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));

In Graph.c:205:

        deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
        slot->out_neighbors = VecInitT(slot->out_neighbors);
        deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
        slot->in_neighbors = VecInitT(slot->in_neighbors);

In Graph.c:235:

    }
    
    static bool graph_neighbors_contains(const GraphNeighbors *neighbors, GraphNodeId node_id) {
        size idx;

In Graph.c:247:

    }
    
    static size graph_find_neighbor_index(const GraphNeighbors *neighbors, GraphNodeId node_id) {
        size idx;

In Graph.c:259:

    }
    
    static size graph_find_pending_edge_removal_index(const GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        size idx;

In Graph.c:272:

    }
    
    static bool graph_remove_edge_now(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        GraphNeighbors *out_neighbors;
        GraphNeighbors *in_neighbors;

In Graph.c:290:

        }
    
        remove_range_vec(GENERIC_VEC(out_neighbors), NULL, sizeof(GraphNodeId), out_idx, 1);
        remove_range_vec(GENERIC_VEC(in_neighbors), NULL, sizeof(GraphNodeId), in_idx, 1);
        graph->edge_count -= 1;

In Graph.c:291:

    
        remove_range_vec(GENERIC_VEC(out_neighbors), NULL, sizeof(GraphNodeId), out_idx, 1);
        remove_range_vec(GENERIC_VEC(in_neighbors), NULL, sizeof(GraphNodeId), in_idx, 1);
        graph->edge_count -= 1;
        return true;

In Graph.c:296:

    }
    
    static size graph_remove_marked_outgoing_edges(GenericGraph *graph, GraphNodeId from) {
        size            removed   = 0;
        GraphNeighbors *neighbors = graph_out_neighbors_ptr(graph, from);

In Graph.c:302:

    
        while (idx < neighbors->length) {
            GraphNodeId             neighbor_id = VecAt(neighbors, idx);
            const GenericGraphSlot *slot;

In Graph.c:321:

    }
    
    static size graph_remove_all_outgoing_edges(GenericGraph *graph, GraphNodeId from) {
        size            removed   = 0;
        GraphNeighbors *neighbors = graph_out_neighbors_ptr(graph, from);

In Graph.c:326:

    
        while (neighbors->length) {
            GraphNodeId to = VecAt(neighbors, neighbors->length - 1);
            if (!graph_remove_edge_now(graph, from, to)) {
                LOG_FATAL("Graph failed to remove outgoing edge during node deletion");

In Graph.c:372:

        for (slot_index = 0; slot_index < graph->slots.length; slot_index++) {
            const GenericGraphSlot *slot = VecPtrAt((GraphSlots *)&graph->slots, slot_index);
            GraphNodeId             self_id = graph_make_node_id((u32)slot_index, slot->generation);
            u64                     neighbor_i;

In Graph.c:393:

    
                for (neighbor_i = 0; neighbor_i < slot->out_neighbors.length; neighbor_i++) {
                    GraphNodeId             neighbor_id  = VecAt(&slot->out_neighbors, neighbor_i);
                    const GenericGraphSlot *target_slot;

In Graph.c:404:

    
                for (neighbor_i = 0; neighbor_i < slot->in_neighbors.length; neighbor_i++) {
                    GraphNodeId             predecessor_id = VecAt(&slot->in_neighbors, neighbor_i);
                    const GenericGraphSlot *source_slot;

In Graph.c:498:

                graph_release_slot(graph, slot, item_size);
            } else {
                deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
                slot->out_neighbors = VecInitT(slot->out_neighbors);
                deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));

In Graph.c:500:

                deinit_vec(GENERIC_VEC(&slot->out_neighbors), sizeof(GraphNodeId));
                slot->out_neighbors = VecInitT(slot->out_neighbors);
                deinit_vec(GENERIC_VEC(&slot->in_neighbors), sizeof(GraphNodeId));
                slot->in_neighbors = VecInitT(slot->in_neighbors);
                slot->visit_count   = 0;

In Graph.c:534:

    }
    
    GraphNodeId graph_push_node(GenericGraph *graph, const void *item_data, size item_size) {
        GraphNodeId       node_id;
        GenericGraphSlot  slot;

In Graph.c:535:

    
    GraphNodeId graph_push_node(GenericGraph *graph, const void *item_data, size item_size) {
        GraphNodeId       node_id;
        GenericGraphSlot  slot;
        GenericGraphSlot *slot_ptr;

In Graph.c:585:

    }
    
    GraphNodeId graph_push_node_owned(GenericGraph *graph, void *item_data, size item_size) {
        GraphNodeId node_id;

In Graph.c:586:

    
    GraphNodeId graph_push_node_owned(GenericGraph *graph, void *item_data, size item_size) {
        GraphNodeId node_id;
    
        if (!graph || !item_data || !item_size) {

In Graph.c:601:

    }
    
    bool graph_contains_node(GenericGraph *graph, GraphNodeId node_id) {
        u32               index;
        u32               generation;

In Graph.c:623:

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

In Graph.c:634:

    }
    
    void *graph_node_ptr_at(GenericGraph *graph, GraphNodeId node_id) {
        return graph_require_live_slot(graph, node_id)->data;
    }

In Graph.c:648:

    }
    
    GraphNeighbors *graph_out_neighbors_ptr(GenericGraph *graph, GraphNodeId node_id) {
        return &graph_require_live_slot(graph, node_id)->out_neighbors;
    }

In Graph.c:652:

    }
    
    GraphNeighbors *graph_in_neighbors_ptr(GenericGraph *graph, GraphNodeId node_id) {
        return &graph_require_live_slot(graph, node_id)->in_neighbors;
    }

In Graph.c:656:

    }
    
    size graph_out_degree(GenericGraph *graph, GraphNodeId node_id) {
        return graph_out_neighbors_ptr(graph, node_id)->length;
    }

In Graph.c:660:

    }
    
    size graph_in_degree(GenericGraph *graph, GraphNodeId node_id) {
        return graph_in_neighbors_ptr(graph, node_id)->length;
    }

In Graph.c:664:

    }
    
    GraphNodeId graph_neighbor_at(GenericGraph *graph, GraphNodeId from, size neighbor_idx) {
        GraphNeighbors *neighbors;

In Graph.c:678:

    }
    
    GraphNodeId graph_predecessor_at(GenericGraph *graph, GraphNodeId to, size predecessor_idx) {
        GraphNeighbors *neighbors;

In Graph.c:692:

    }
    
    bool graph_has_edge(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        GraphNeighbors *neighbors;

In Graph.c:703:

    }
    
    bool graph_add_edge(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        GraphNeighbors *out_neighbors;
        GraphNeighbors *in_neighbors;

In Graph.c:717:

    
        in_neighbors = graph_in_neighbors_ptr(graph, to);
        insert_range_into_vec(GENERIC_VEC(out_neighbors), (char *)&to, sizeof(GraphNodeId), out_neighbors->length, 1);
        insert_range_into_vec(GENERIC_VEC(in_neighbors), (char *)&from, sizeof(GraphNodeId), in_neighbors->length, 1);
        graph->edge_count += 1;

In Graph.c:718:

        in_neighbors = graph_in_neighbors_ptr(graph, to);
        insert_range_into_vec(GENERIC_VEC(out_neighbors), (char *)&to, sizeof(GraphNodeId), out_neighbors->length, 1);
        insert_range_into_vec(GENERIC_VEC(in_neighbors), (char *)&from, sizeof(GraphNodeId), in_neighbors->length, 1);
        graph->edge_count += 1;
        graph_bump_mutation_epoch(graph);

In Graph.c:810:

    }
    
    bool graph_mark_edge_for_removal(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        GraphPendingEdgeRemoval pending;

In Graph.c:838:

    }
    
    bool graph_edge_marked_for_removal(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        ValidateGraph(graph);
        graph_validate_node_id(graph, from);

In Graph.c:846:

    }
    
    bool graph_unmark_edge_for_removal(GenericGraph *graph, GraphNodeId from, GraphNodeId to) {
        size idx;

In Graph.c:884:

            GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
            if (graph_slot_is_occupied(slot) && graph_slot_is_marked(slot)) {
                GraphNodeId marked_id = graph_make_node_id((u32)slot_index, slot->generation);
                (void)graph_remove_all_outgoing_edges(graph, marked_id);
            }

In Graph.c:892:

            GenericGraphSlot *slot = VecPtrAt(&graph->slots, slot_index);
            if (graph_slot_is_occupied(slot) && !graph_slot_is_marked(slot)) {
                GraphNodeId live_id = graph_make_node_id((u32)slot_index, slot->generation);
                (void)graph_remove_marked_outgoing_edges(graph, live_id);
            }

In Graph.c:989:

    
        while (iter->neighbor_index < neighbors->length) {
            GraphNodeId neighbor_id = VecAt(neighbors, iter->neighbor_index);
            iter->neighbor_index += 1;

In Graph.c:1036:

    
        while (iter->predecessor_index < neighbors->length) {
            GraphNodeId predecessor_id = VecAt(neighbors, iter->predecessor_index);
            iter->predecessor_index += 1;

In Graph.Foreach.c:29:

    
    static u64 node_id_hash(const void *data, u32 size) {
        u64 x = *(const GraphNodeId *)data;
        (void)size;

In Graph.Foreach.c:41:

    
    static i32 node_id_compare(const void *lhs, const void *rhs) {
        GraphNodeId a = *(const GraphNodeId *)lhs;
        GraphNodeId b = *(const GraphNodeId *)rhs;
        return (a > b) - (a < b);

In Graph.Foreach.c:42:

    static i32 node_id_compare(const void *lhs, const void *rhs) {
        GraphNodeId a = *(const GraphNodeId *)lhs;
        GraphNodeId b = *(const GraphNodeId *)rhs;
        return (a > b) - (a < b);
    }

In Graph.Foreach.c:47:

    
    typedef Graph(Str)                 CityGraph;
    typedef Map(const char *, GraphNodeId) CityIndex;
    
    static GraphNodeId city_add_intersection(CityGraph *graph, CityIndex *index, const char *name) {

In Graph.Foreach.c:49:

    typedef Map(const char *, GraphNodeId) CityIndex;
    
    static GraphNodeId city_add_intersection(CityGraph *graph, CityIndex *index, const char *name) {
        Str         intersection = StrInitFromZstr(name);
        GraphNodeId id           = GraphAddNodeL(graph, intersection);

In Graph.Foreach.c:51:

    static GraphNodeId city_add_intersection(CityGraph *graph, CityIndex *index, const char *name) {
        Str         intersection = StrInitFromZstr(name);
        GraphNodeId id           = GraphAddNodeL(graph, intersection);
    
        MapInsertR(index, name, id);

In Graph.Foreach.c:64:

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

In Graph.Foreach.c:84:

    
    static bool city_reachable(CityGraph *graph, CityIndex *index, const char *from, const char *to) {
        GraphNodeId *from_id = MapTryGetPtr(index, from);
        GraphNodeId *to_id   = MapTryGetPtr(index, to);

In Graph.Foreach.c:85:

    static bool city_reachable(CityGraph *graph, CityIndex *index, const char *from, const char *to) {
        GraphNodeId *from_id = MapTryGetPtr(index, from);
        GraphNodeId *to_id   = MapTryGetPtr(index, to);
    
        if (!from_id || !to_id) {

In Graph.Foreach.c:101:

        CityIndex index = MapInitWithDeepCopy(zstr_hash, zstr_compare_ptr, ZstrInitClone, ZstrDeinit, NULL, NULL);
    
        GraphNodeId alpha = city_add_intersection(&graph, &index, "Alpha");
        GraphNodeId beta  = city_add_intersection(&graph, &index, "Beta");
        GraphNodeId gamma = city_add_intersection(&graph, &index, "Gamma");

In Graph.Foreach.c:102:

    
        GraphNodeId alpha = city_add_intersection(&graph, &index, "Alpha");
        GraphNodeId beta  = city_add_intersection(&graph, &index, "Beta");
        GraphNodeId gamma = city_add_intersection(&graph, &index, "Gamma");
        GraphNodeId delta = city_add_intersection(&graph, &index, "Delta");

In Graph.Foreach.c:103:

        GraphNodeId alpha = city_add_intersection(&graph, &index, "Alpha");
        GraphNodeId beta  = city_add_intersection(&graph, &index, "Beta");
        GraphNodeId gamma = city_add_intersection(&graph, &index, "Gamma");
        GraphNodeId delta = city_add_intersection(&graph, &index, "Delta");
        GraphNodeId echo  = city_add_intersection(&graph, &index, "Echo");

In Graph.Foreach.c:104:

        GraphNodeId beta  = city_add_intersection(&graph, &index, "Beta");
        GraphNodeId gamma = city_add_intersection(&graph, &index, "Gamma");
        GraphNodeId delta = city_add_intersection(&graph, &index, "Delta");
        GraphNodeId echo  = city_add_intersection(&graph, &index, "Echo");

In Graph.Foreach.c:105:

        GraphNodeId gamma = city_add_intersection(&graph, &index, "Gamma");
        GraphNodeId delta = city_add_intersection(&graph, &index, "Delta");
        GraphNodeId echo  = city_add_intersection(&graph, &index, "Echo");
    
        GraphAddEdge(&graph, alpha, beta);

In Graph.Foreach.c:132:

    
        typedef Graph(int) IntGraph;
        typedef Map(GraphNodeId, u64) CountMap;
    
        IntGraph graph  = GraphInit();

In Graph.Foreach.c:137:

        CountMap counts = MapInit(node_id_hash, node_id_compare);
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Foreach.c:138:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:139:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:140:

        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);
    
        GraphAddEdge(&graph, a, b);

In Graph.Foreach.c:171:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Foreach.c:172:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:173:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:174:

        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);
    
        GraphAddEdge(&graph, a, d);

In Graph.Foreach.c:222:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Foreach.c:223:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Foreach.c:224:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
    
        GraphAddEdge(&graph, a, b);

In Graph.Foreach.c:243:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Foreach.c:244:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:245:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);

In Graph.Foreach.c:246:

        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
        GraphNodeId d = GraphAddNodeR(&graph, 4);
    
        GraphAddEdge(&graph, a, c);

In Graph.Ops.c:12:

        IntGraph graph = GraphInit();
    
        GraphNodeId a    = GraphAddNodeR(&graph, 10);
        GraphNode   node = GraphGetNode(&graph, a);

In Graph.Ops.c:35:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:36:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:37:

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

In Graph.Ops.c:62:

        result = result && (GraphPredecessorAt(&graph, a, 0) == c);
    
        GraphNodeId d = GraphAddNodeR(&graph, 40);
    
        result = result && (GraphNodeIdIndex(d) == GraphNodeIdIndex(b));

In Graph.Ops.c:79:

        IntGraph graph = GraphInit();
    
        GraphNodeId a    = GraphAddNodeR(&graph, 10);
        GraphNode   node = GraphGetNode(&graph, a);

In Graph.Ops.c:103:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:104:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:105:

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

In Graph.Ops.c:149:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);

In Graph.Ops.c:150:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        GraphAddEdge(&graph, a, b);

In Graph.Ops.c:175:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:176:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:177:

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

In Graph.Ops.c:206:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
    
        bool result = GraphAddEdge(&graph, a, a);

In Graph.Ops.c:229:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Ops.c:230:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);
        GraphNodeId d = GraphAddNodeR(&graph, 40);

In Graph.Ops.c:231:

        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);
        GraphNodeId d = GraphAddNodeR(&graph, 40);

In Graph.Ops.c:232:

        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);
        GraphNodeId d = GraphAddNodeR(&graph, 40);
    
        GraphAddEdge(&graph, a, b);

In Graph.Ops.c:262:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        u64         counts[2] = {0};

In Graph.Ops.c:263:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        u64         counts[2] = {0};

In Graph.Ops.c:273:

        result      = result && !GraphContainsNode(&graph, b);
    
        GraphNodeId reused = GraphAddNodeR(&graph, 99);
    
        result = result && (GraphNodeIdIndex(reused) == GraphNodeIdIndex(b));

In Graph.Ops.c:294:

        IntGraph graph = GraphInit();
    
        GraphNodeId a    = GraphAddNodeR(&graph, 10);
        GraphNode   node = GraphGetNode(&graph, a);

In Graph.Init.c:17:

    
        bool        result           = graph.slots.capacity >= 8;
        GraphNodeId first_id         = GraphAddNodeR(&graph, 10);
        GraphNodeId second_id        = GraphAddNodeR(&graph, 20);
        GraphNodeId third_id         = GraphAddNodeR(&graph, 30);

In Graph.Init.c:18:

        bool        result           = graph.slots.capacity >= 8;
        GraphNodeId first_id         = GraphAddNodeR(&graph, 10);
        GraphNodeId second_id        = GraphAddNodeR(&graph, 20);
        GraphNodeId third_id         = GraphAddNodeR(&graph, 30);
        u64         slot_count       = graph.slots.length;

In Graph.Init.c:19:

        GraphNodeId first_id         = GraphAddNodeR(&graph, 10);
        GraphNodeId second_id        = GraphAddNodeR(&graph, 20);
        GraphNodeId third_id         = GraphAddNodeR(&graph, 30);
        u64         slot_count       = graph.slots.length;
        size        slot_capacity    = graph.slots.capacity;

In Graph.Init.c:67:

        StrGraph   graph = GraphInitWithDeepCopy(StrInitCopy, StrDeinit);
        Str        name  = StrInitFromZstr("alpha");
        GraphNodeId node_id;
        GraphNode   node;
        Str        *stored_name;

In Graph.Type.c:30:

        IntGraph graph = GraphInitAligned(32);
    
        GraphNodeId node_id = GraphAddNodeR(&graph, 11);
        GraphNode   node    = GraphGetNode(&graph, node_id);

In Graph.Access.c:12:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
        GraphNodeId c = GraphAddNodeR(&graph, 30);

In Graph.Access.c:13:

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

In Graph.Access.c:14:

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

In Graph.Access.c:51:

        ZstrGraph graph = GraphInit();
    
        GraphNodeId red   = GraphAddNodeR(&graph, "red");
        GraphNodeId green = GraphAddNodeR(&graph, "green");
        GraphNodeId blue  = GraphAddNodeR(&graph, "blue");

In Graph.Access.c:52:

    
        GraphNodeId red   = GraphAddNodeR(&graph, "red");
        GraphNodeId green = GraphAddNodeR(&graph, "green");
        GraphNodeId blue  = GraphAddNodeR(&graph, "blue");

In Graph.Access.c:53:

        GraphNodeId red   = GraphAddNodeR(&graph, "red");
        GraphNodeId green = GraphAddNodeR(&graph, "green");
        GraphNodeId blue  = GraphAddNodeR(&graph, "blue");
    
        GraphAddEdge(&graph, red, green);

In Graph.Access.c:89:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);

In Graph.Access.c:90:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        GraphAddEdge(&graph, a, b);

In Graph.Access.c:105:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);

In Graph.Access.c:106:

    
        GraphNodeId a = GraphAddNodeR(&graph, 10);
        GraphNodeId b = GraphAddNodeR(&graph, 20);
    
        GraphAddEdge(&graph, a, b);

In Graph.Insert.c:14:

        int      shared = 7;
    
        GraphNodeId id0 = GraphAddNodeL(&graph, owned);
        GraphNodeId id1 = GraphAddNodeR(&graph, shared);

In Graph.Insert.c:15:

    
        GraphNodeId id0 = GraphAddNodeL(&graph, owned);
        GraphNodeId id1 = GraphAddNodeR(&graph, shared);
    
        bool result = GraphNodeIdIndex(id0) == 0 && GraphNodeIdGeneration(id0) == 1 && GraphNodeIdIndex(id1) == 1;

In Graph.Insert.c:32:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Insert.c:33:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Insert.c:34:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
    
        bool result = GraphAddEdge(&graph, a, b);

In Graph.Insert.c:59:

        IntGraph graph = GraphInit();
    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Insert.c:60:

    
        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);

In Graph.Insert.c:61:

        GraphNodeId a = GraphAddNodeR(&graph, 1);
        GraphNodeId b = GraphAddNodeR(&graph, 2);
        GraphNodeId c = GraphAddNodeR(&graph, 3);
    
        bool result = GraphAddEdge(&graph, a, a);

In Type.h:37:

    /// TAGS: Graph, Node, Id, Index
    ///
    #define GraphNodeIdIndex(id) ((u32)((GraphNodeId)(id) & UINT32_MAX))
    
    ///

In Type.h:49:

    /// TAGS: Graph, Node, Id, Generation
    ///
    #define GraphNodeIdGeneration(id) ((u32)(((GraphNodeId)(id) >> 32) & UINT32_MAX))
    
    ///

In Type.h:65:

    typedef struct {
        void       *__graph;
        GraphNodeId __id;
    } GraphNode;

In Type.h:76:

    /// TAGS: Graph, Edge, Neighbor, Vec
    ///
    typedef Vec(GraphNodeId) GraphNeighbors;
    
    typedef struct {

In Type.h:91:

    
    typedef struct {
        GraphNodeId from;
        GraphNodeId to;
    } GraphPendingEdgeRemoval;

In Type.h:92:

    typedef struct {
        GraphNodeId from;
        GraphNodeId to;
    } GraphPendingEdgeRemoval;

Last updated on April 28, 2026

GraphNodeGetId GraphNodeIdGeneration