Struct DependencyGraph 

pub struct DependencyGraph { /* private fields */ }

Dependency graph for computing startup order

Builds a directed acyclic graph (DAG) from service dependencies and provides topological sorting for startup ordering.

Implementations

impl DependencyGraph

pub fn build(services: &HashMap<String, ServiceSpec>) -> Result<Self>

Build a dependency graph from a set of services

Arguments

• services - Map of service name to service specification

Returns

A validated dependency graph with computed startup order

Errors

• DependencyError::CyclicDependency if a cycle is detected
• DependencyError::MissingService if a dependency references a non-existent service
• DependencyError::SelfDependency if a service depends on itself

Panics

Panics if internal adjacency map state is inconsistent (should never happen).

pub fn detect_cycle(&self) -> Option<Vec<String>>

Detect cycles using DFS with three-color marking

Colors:

• White (0): Not visited
• Gray (1): Currently being visited (in recursion stack)
• Black (2): Completely visited

Returns the cycle path if found, None otherwise

pub fn topological_order(&self) -> Vec<String>

Compute topological order using Kahn’s algorithm

Services with no dependencies come first (they can start immediately). Returns services in order they should be started.

pub fn startup_order(&self) -> &[String]

Get the startup order (services with no deps first)

pub fn dependencies(&self, service: &str) -> Option<&[DependsSpec]>

Get dependencies for a specific service

pub fn len(&self) -> usize

Get the number of services in the graph

pub fn is_empty(&self) -> bool

Check if the graph is empty

pub fn depends_on(&self, a: &str, b: &str) -> bool

Check if service A depends on service B (directly or transitively)

pub fn dependents(&self, service: &str) -> Vec<String>

Get services that directly depend on the given service

Trait Implementations

impl Debug for DependencyGraph

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

Formats the value using the given formatter.