Struct Resolver 

pub struct Resolver { /* private fields */ }

Iterative dependency resolver that works in levels.

Instead of using a callback for index lookups (which would require blocking HTTP inside an async runtime), this resolver works in a pull-based way:

1. Call seed() with your direct dependencies
2. Call pending_crates() to get crate names that need index data
3. Fetch those indexes (async, in the caller)
4. Call provide_index() for each fetched index
5. Call advance() to process one level of the graph
6. Repeat 2-5 until pending_crates() returns empty
7. Call finish() to get the resolved graph

Implementations

impl Resolver

pub fn new() -> Self

pub fn seed(&mut self, deps: &BTreeMap<String, String>)

Seed the resolver with direct dependencies from depends.toml.

pub fn provide_index(&mut self, name: &str, entries: Vec<IndexEntry>)

Provide index entries for a crate (fetched by the caller).

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

Return the names of crates that are queued but whose index data is not yet in the cache. The caller should fetch these and call provide_index before calling advance.

pub fn has_work(&self) -> bool

Returns true if there are still crates to resolve.

pub fn advance(&mut self) -> Result<()>

Process all currently queued crates. This resolves their versions, computes enabled features, and enqueues their transitive deps. After this call, pending_crates() may return new names to fetch.

pub fn finish(self, direct_deps: &BTreeMap<String, String>) -> ResolvedGraph

Consume the resolver and return the final resolved graph.