Struct RuleDependencyGraph 

pub struct RuleDependencyGraph { /* private fields */ }

Directed graph capturing dependencies between rules and predicates.

Implementations

impl RuleDependencyGraph

pub fn new() -> Self

Create an empty graph.

pub fn add_node(&mut self, node: DepNode)

Insert a node (idempotent).

pub fn add_edge(&mut self, from: DepNode, to: DepNode, edge: DepEdge)

Insert a directed edge from from to to with edge type edge. Both endpoints are automatically added as nodes.

pub fn from_symbol_table(table: &SymbolTable) -> Self

Build a dependency graph from a SymbolTable.

Because SymbolTable stores predicates (not first-class rules with heads/bodies), this method treats each predicate as both a defining entity and a potential dependency. For every predicate p it:

1. Adds Predicate(p.name) as a node.
2. Creates a synthetic Rule("<p>_rule") that defines p.
3. Adds a Defines edge from the rule node to the predicate node.
4. For each argument domain d of p: adds Predicate(d) and a Positive edge from the rule to that domain predicate (modelling that evaluating p requires its domain to be populated).

pub fn nodes(&self) -> &HashSet<DepNode>

All nodes in the graph.

pub fn successors(&self, node: &DepNode) -> Vec<&DepNode>

Nodes that node has outgoing edges to (successors / dependencies).

pub fn predecessors(&self, node: &DepNode) -> Vec<&DepNode>

Nodes that have outgoing edges pointing to node (predecessors).

pub fn node_count(&self) -> usize

Total number of nodes.

pub fn edge_count(&self) -> usize

Total number of directed edges.

pub fn has_cycle(&self) -> bool

Returns true if the graph contains at least one directed cycle.

pub fn find_cycle_nodes(&self) -> HashSet<&DepNode>

Return the set of nodes that participate in any cycle.

pub fn transitive_deps(&self, node: &DepNode) -> HashSet<DepNode>

Compute all nodes reachable from node via BFS (all edge types). The starting node itself is not included in the result.

pub fn strongly_connected_components(&self) -> Vec<Vec<DepNode>>

Compute all strongly connected components. Each SCC is returned as a Vec<DepNode>; SCCs are in reverse topological order (i.e. the first SCC has no outgoing edges to later SCCs).

pub fn stratify(&self) -> Result<Vec<StratificationLayer>, StratificationError>

Compute Datalog stratification layers.

Returns Ok(layers) where layers are sorted by stratum index, or Err(StratificationError::NegativeCycle{..}) when the graph is unstratifiable.

pub fn to_ascii(&self) -> String

Render as a human-readable ASCII adjacency list (for debugging).

pub fn to_dot(&self) -> String

Render as Graphviz DOT format.

Trait Implementations

impl Clone for RuleDependencyGraph

fn clone(&self) -> RuleDependencyGraph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuleDependencyGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RuleDependencyGraph

fn default() -> Self

Returns the “default value” for a type.