Struct GraphMut 

pub struct GraphMut<'a> {
    pub ids: &'a IdMap,
    pub syms: &'a mut Interner,
    pub labels: &'a [u32],
    pub props: ColumnsView<'a>,
    pub topo: &'a mut Topology,
    pub base_topo: Option<&'a ArchivedCsr>,
    pub edge_props: &'a mut EdgeProps,
}

Borrowed mutable view of graph state the engine writes derived edges into.

Fields

ids: &'a IdMap

syms: &'a mut Interner

labels: &'a [u32]

props: ColumnsView<'a>

topo: &'a mut Topology

Edges written since the snapshot. Reads must go through GraphMut::neighbors, not this field: on a store opened from a snapshot the overlay is empty and every edge lives in base_topo.

base_topo: Option<&'a ArchivedCsr>

The snapshot’s archived CSR, when one is open. None for a store with no snapshot, where topo already holds everything.

edge_props: &'a mut EdgeProps

Implementations

impl GraphMut<'_>

pub fn add_edge(&mut self, etype: u32, src: u32, dst: u32) -> bool

Add a derived edge, reporting whether it was not there before — counting the snapshot’s edges as well as the overlay’s.

Topology::add_edge looks at the overlay alone. On a store opened from a snapshot, an edge one rule derived before the snapshot lives in the base, so a second rule over the same edge type that desires it was told it was new: it recorded the edge as its own beside the first rule, the edge was counted twice, and when the second rule let go of it the edge went from the graph while the first rule still counted it (ledger row 103). Every derived-edge insert in the engine goes through here.

A binary search of the base row and a tombstone lookup, not a merge of the row: building the merged row for each insert made re-deriving a hub’s out-edges after a snapshot quadratic in its degree.

pub fn remove_edge(&mut self, etype: u32, src: u32, dst: u32)

Remove a derived edge, recording a tombstone only when the snapshot holds the edge.

Topology::remove_edge tombstones any edge the overlay lacks. A retraction can name an edge the graph holds nowhere — a store in which 0.8.0 had already lost an edge one rule still owned — and a tombstone over it is counted as a removed snapshot edge, so the edge count read one low per such retraction until the next snapshot (ledger row 109). Every derived-edge removal in the engine goes through here.

pub fn neighbors(&self, etype: u32, dir: Direction, v: u32) -> Cow<'_, [u32]>

Neighbours of v over (etype, dir), merging the snapshot base with the post-snapshot overlay and subtracting the overlay’s tombstones.

A rule that reads the graph’s shape — today only a via-hop rule, when it expands its hop — must use this rather than topo directly. Reading the overlay alone on a store opened from a snapshot returns nothing, which a via-hop rule cannot distinguish from “this source reaches no via node” and answers by retracting every edge it owns.