Struct pubgrub::solver::OfflineDependencyProvider

pub struct OfflineDependencyProvider<P: Package, VS: VersionSet> { /* private fields */ }

A basic implementation of DependencyProvider.

Implementations

impl<P: Package, VS: VersionSet> OfflineDependencyProvider<P, VS>

pub fn new() -> Self

Creates an empty OfflineDependencyProvider with no dependencies.

pub fn add_dependencies<I: IntoIterator<Item = (P, VS)>>( &mut self, package: P, version: impl Into<VS::V>, dependencies: I )

Registers the dependencies of a package and version pair. Dependencies must be added with a single call to add_dependencies. All subsequent calls to add_dependencies for a given package version pair will replace the dependencies by the new ones.

The API does not allow to add dependencies one at a time to uphold an assumption that OfflineDependencyProvider.get_dependencies(p, v) provides all dependencies of a given package (p) and version (v) pair.

pub fn packages(&self) -> impl Iterator<Item = &P>

Lists packages that have been saved.

pub fn versions(&self, package: &P) -> Option<impl Iterator<Item = &VS::V>>

Lists versions of saved packages in sorted order. Returns None if no information is available regarding that package.

Trait Implementations

impl<P: Clone + Package, VS: Clone + VersionSet> Clone for OfflineDependencyProvider<P, VS>

where VS::V: Clone,

fn clone(&self) -> OfflineDependencyProvider<P, VS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Package, VS: Debug + VersionSet> Debug for OfflineDependencyProvider<P, VS>

where VS::V: Debug,

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

Formats the value using the given formatter.

impl<P: Default + Package, VS: Default + VersionSet> Default for OfflineDependencyProvider<P, VS>

where VS::V: Default,

fn default() -> OfflineDependencyProvider<P, VS>

Returns the “default value” for a type.

impl<P: Package, VS: VersionSet> DependencyProvider for OfflineDependencyProvider<P, VS>

An implementation of DependencyProvider that contains all dependency information available in memory. Currently packages are picked with the fewest versions contained in the constraints first. But, that may change in new versions if better heuristics are found. Versions are picked with the newest versions first.

type P = P

How this provider stores the name of the packages.

type V = <VS as VersionSet>::V

How this provider stores the versions of the packages.

type VS = VS

How this provider stores the version requirements for the packages. The requirements must be able to process the same kind of version as this dependency provider.

type Err = Infallible

The kind of error returned from these methods.

fn choose_version( &self, package: &P, range: &VS ) -> Result<Option<VS::V>, Infallible>

Once the resolver has found the highest Priority package from all potential valid packages, it needs to know what vertion of that package to use. The most common pattern is to select the largest vertion that the range contains.

type Priority = Reverse<usize>

The type returned from prioritize. The resolver does not care what type this is as long as it can pick a largest one and clone it.

fn prioritize(&self, package: &P, range: &VS) -> Self::Priority

Decision making is the process of choosing the next package and version that will be appended to the partial solution.

fn get_dependencies( &self, package: &P, version: &VS::V ) -> Result<Dependencies<P, VS>, Infallible>

Retrieves the package dependencies. Return Dependencies::Unknown if its dependencies are unknown.

fn should_cancel(&self) -> Result<(), Self::Err>

This is called fairly regularly during the resolution, if it returns an Err then resolution will be terminated. This is helpful if you want to add some form of early termination like a timeout, or you want to add some form of user feedback if things are taking a while. If not provided the resolver will run as long as needed.