Struct PackageIndex 

pub struct PackageIndex { /* private fields */ }

PackageIndex is used as an in-memory database of package information needed for dependency resolution for Miden projects. It records and can provide information about:

• All packages for which there is at least one version available
• All versions of a package that are available
• The dependencies for each version of a package, and their version requirements.

Additionally, PackageIndex implements version selection and dependency resolution for packages in the index. Since this functionality is central to any tooling around Miden projects, we implement it here, rather than push the responsibility onto downstream crates.

This structure does not provide any of the following:

• Package metadata beyond version and dependency requirements
• MAST of indexed packages
• A guarantee that indexed packages actually exist or that their sources/MAST can be obtained

It is up to downstream consumers of the index to construct it and populate it with packages known to them, such that packages selected by PackageResolver::resolve can be resolved to relevant artifacts, e.g. an assembled package, Miden project sources, etc.

Implementations

impl PackageIndex

Construction

pub fn register(&mut self, package: &Package)

Register package in the index.

This is essentially a convenience wrapper around PackageIndex::insert for the common case of populating the index with package information loaded from a Miden project.

pub fn insert<D, P, V>( &mut self, name: impl Into<PackageId>, version: Version, dependencies: D, )

where D: IntoIterator<Item = (P, V)>, P: Into<PackageId>, V: Into<VersionSet>,

Insert a new entry in the index for name and version, with dependencies providing the set of version constraints for the package dependencies.

impl PackageIndex

Queries

pub fn is_available<Q>(&self, name: &Q) -> bool

where PackageId: Borrow<Q>, Q: Ord + ?Sized,

Returns true if package name has any available versions in the index.

pub fn is_version_available<Q>(&self, name: &Q, version: &Version) -> bool

where PackageId: Borrow<Q>, Q: Ord + ?Sized,

Returns true if package name with version is available in the index.

pub fn find<Q>( &self, name: &Q, requirement: &VersionRequirement, ) -> Option<&BTreeMap<PackageId, VersionSet>>

where PackageId: Borrow<Q>, Q: Ord + ?Sized,

Search for a version of package name that matches requirement, and return its dependencies.

The version selected by this method will be the latest one which satisfies requirement.

pub fn available_versions<Q>( &self, package: &Q, ) -> impl Iterator<Item = &Version>

where PackageId: Borrow<Q>, Q: Ord + ?Sized,

Get an iterator over all versions of package available in the index, in descending order.

NOTE: Descending order here is determined by the Ord implementation of Version, which orders versions by their semantic versioning scheme, and disambiguates using package digests when known.

pub fn list_versions<'a, Q>( &'a self, package: &'a Q, requirement: &'a VersionRequirement, ) -> impl Iterator<Item = &'a Version> + 'a

where PackageId: Borrow<Q>, Q: Ord + ?Sized,

Get an iterator over all versions of package that satisfy `requirement.

Trait Implementations

impl Default for PackageIndex

fn default() -> PackageIndex

Returns the “default value” for a type.

impl<'a, V, D> FromIterator<(&'a str, V)> for PackageIndex

where D: IntoIterator<Item = (&'a str, VersionSet)>, V: IntoIterator<Item = (Version, D)>,

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = (&'a str, V)>,

Creates a value from an iterator.