Struct stack_graphs::stitching::Database

pub struct Database { /* private fields */ }

Contains a “database” of partial paths.

This type is meant to be a lazily loaded “view” into a proper storage layer. During the path-stitching algorithm, we repeatedly try to extend a currently incomplete path with any partial paths that are compatible with it. For large codebases, or projects with a large number of dependencies, it can be prohibitive to load in all of the partial paths up-front. We’ve written the path-stitching algorithm so that you have a chance to only load in the partial paths that are actually needed, placing them into a Database instance as they’re needed.

Implementations

impl Database

pub fn new() -> Database

Creates a new, empty database.

pub fn add_partial_path(
    &mut self,
    graph: &StackGraph,
    partials: &mut PartialPaths,
    path: PartialPath
) -> Handle<PartialPath>

Adds a partial path to this database. We do not deduplicate partial paths in any way; it’s your responsibility to only add each partial path once.

pub fn find_candidate_partial_paths_from_root<R>(
    &mut self,
    graph: &StackGraph,
    partials: &mut PartialPaths,
    symbol_stack: SymbolStackKey,
    result: &mut R
)where
    R: Extend<Handle<PartialPath>>,

Find all partial paths in this database that start at the root node, and have a symbol stack precondition that is compatible with a given symbol stack.

pub fn find_candidate_partial_paths_from_node<R>(
    &self,
    graph: &StackGraph,
    partials: &mut PartialPaths,
    start_node: Handle<Node>,
    result: &mut R
)where
    R: Extend<Handle<PartialPath>>,

Find all partial paths in the database that start at the given node. We don’t filter the results any further than that, since we have to check each partial path for compatibility as we try to append it to the current incomplete path anyway, and non-root nodes will typically have a small number of outgoing edges.

pub fn find_local_nodes(&mut self)

Determines which nodes in the stack graph are “local”, taking into account the partial paths in this database.

A local node has no partial path that connects it to the root node in either direction. That means that it cannot participate in any paths that leave the file.

This method is meant to be used at index time, to calculate the set of nodes that are local after having just calculated the set of partial paths for the file.

pub fn mark_local_node(&mut self, node: Handle<Node>)

Marks that a stack graph node is local.

This method is meant to be used at query time. You will have precalculated the set of local nodes for a file at index time; at query time, you will load this information from your storage layer and use this method to update our internal view of which nodes are local.

pub fn node_is_local(&self, node: Handle<Node>) -> bool

Returns whether a node is local according to the partial paths in this database. You must have already called [find_local_nodes][] or [mark_local_node][], depending on whether it is index time or query time.

pub fn iter_partial_paths(&self) -> impl Iterator<Item = Handle<PartialPath>>

Returns an iterator over all of the handles of all of the partial paths in this database. (Note that because we’re only returning handles, this iterator does not retain a reference to the Database.)

pub fn ensure_both_directions(&mut self, partials: &mut PartialPaths)

pub fn ensure_forwards(&mut self, partials: &mut PartialPaths)

Trait Implementations

impl Index<Handle<PartialPath>> for Database

type Output = PartialPath

The returned type after indexing.

fn index(&self, handle: Handle<PartialPath>) -> &PartialPath

Performs the indexing (container[index]) operation.