Struct ModuleGraphRef 

pub struct ModuleGraphRef {
    pub graphs: Vec<ReadRef<SingleModuleGraph>>,
}

The ReadRef version of ModuleGraph. This is better for eventual consistency, as the graphs aren’t awaited multiple times within the same task.

Fields

graphs: Vec<ReadRef<SingleModuleGraph>>

Implementations

impl ModuleGraphRef

pub async fn get_ids( &self, ) -> Result<FxHashMap<ResolvedVc<Box<dyn Module>>, ReadRef<RcStr>>>

Returns a map of all modules in the graphs to their identifiers. This is primarily useful for debugging.

pub fn traverse_edges_from_entries_bfs( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, visitor: impl FnMut(Option<(&SingleModuleGraphModuleNode, &RefData)>, &SingleModuleGraphModuleNode) -> Result<GraphTraversalAction>, ) -> Result<()>

Traverses all reachable edges exactly once and calls the visitor with the edge source and target.

This means that target nodes can be revisited (once per incoming edge).

• entry - The entry module to start the traversal from
• visitor - Called before visiting the children of a node.
  • Receives (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal

pub fn traverse_edges_from_entry( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, visitor: impl FnMut(Option<(&SingleModuleGraphModuleNode, &RefData)>, &SingleModuleGraphModuleNode) -> GraphTraversalAction, ) -> Result<()>

Traverses all reachable edges exactly once and calls the visitor with the edge source and target.

This means that target nodes can be revisited (once per incoming edge).

• entry - The entry module to start the traversal from
• visitor - Called before visiting the children of a node.
  • Receives (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal

pub fn traverse_all_edges_unordered( &self, visitor: impl FnMut((&SingleModuleGraphModuleNode, &RefData), &SingleModuleGraphModuleNode) -> Result<()>, ) -> Result<()>

Traverses all edges exactly once (in an unspecified order) and calls the visitor with the edge source and target.

This means that target nodes can be revisited (once per incoming edge).

• visitor - Called before visiting the children of a node.
  • Receives (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode

pub fn traverse_edges_from_entries_dfs<S>( &self, entries: impl IntoIterator<Item = ResolvedVc<Box<dyn Module>>>, state: &mut S, visit_preorder: impl FnMut(Option<(&SingleModuleGraphModuleNode, &RefData)>, &SingleModuleGraphModuleNode, &mut S) -> Result<GraphTraversalAction>, visit_postorder: impl FnMut(Option<(&SingleModuleGraphModuleNode, &RefData)>, &SingleModuleGraphModuleNode, &mut S) -> Result<()>, ) -> Result<()>

Traverses all reachable edges in dfs order. The preorder visitor can be used to forward state down the graph, and to skip subgraphs

Use this to collect modules in evaluation order.

Target nodes can be revisited (once per incoming edge) in the preorder_visitor, in the post order visitor they are visited exactly once with the first edge they were discovered with. Edges are traversed in normal order, so should correspond to reference order.

• entries - The entry modules to start the traversal from
• state - The state to be passed to the visitors
• visit_preorder - Called before visiting the children of a node.
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal
• visit_postorder - Called after visiting the children of a node. Return
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Can return GraphTraversalActions to control the traversal

pub fn traverse_cycles( &self, edge_filter: impl Fn(&RefData) -> bool, visit_cycle: impl FnMut(&[&SingleModuleGraphModuleNode]), ) -> Result<()>

Traverse all cycles in the graph (where the edge filter returns true for the whole cycle) and call the visitor with the nodes in the cycle.

pub fn traverse_edges_fixed_point_with_priority<S, P: Ord>( &self, entries: impl IntoIterator<Item = (ResolvedVc<Box<dyn Module>>, P)>, state: &mut S, visit: impl FnMut(Option<(&SingleModuleGraphModuleNode, &RefData)>, &SingleModuleGraphModuleNode, &mut S) -> Result<GraphTraversalAction>, priority: impl Fn(&SingleModuleGraphModuleNode, &mut S) -> Result<P>, ) -> Result<usize>

Traverses all reachable nodes and also continue revisiting them as long the visitor returns GraphTraversalAction::Continue. The visitor is responsible for the runtime complexity and eventual termination of the traversal. This corresponds to computing a fixed point state for the graph.

Nodes are (re)visited according to the returned priority of the node, prioritizing high values. This priority is intended to be used a heuristic to reduce the number of retraversals.

• entries - The entry modules to start the traversal from
• state - The state to be passed to the callbacks
• visit - Called for a specific edge
  • Receives: (originating &SingleModuleGraphNode, edge &ChunkingType), target &SingleModuleGraphNode, state &S
  • Return GraphTraversalActions to control the traversal
• priority - Called for before visiting the children of a node to determine its priority.
  • Receives: target &SingleModuleGraphNode, state &S
  • Return a priority value for the node

Returns the number of node visits (i.e. higher than the node count if there are retraversals).