Struct cargo::core::resolver::Resolve

pub struct Resolve { /* private fields */ }

Represents a fully-resolved package dependency graph. Each node in the graph is a package and edges represent dependencies between packages.

Each instance of Resolve also understands the full set of features used for each package.

Implementations

impl Resolve

pub fn new(
    graph: Graph<PackageId, HashSet<Dependency>>,
    replacements: HashMap<PackageId, PackageId>,
    features: HashMap<PackageId, Vec<InternedString>>,
    checksums: HashMap<PackageId, Option<String>>,
    metadata: Metadata,
    unused_patches: Vec<PackageId>,
    version: ResolveVersion,
    summaries: HashMap<PackageId, Summary>
) -> Resolve

pub fn path_to_top<'a>(
    &'a self,
    pkg: &'a PackageId
) -> Vec<(&'a PackageId, Option<&'a HashSet<Dependency>>)>

Resolves one of the paths from the given dependent package up to the root.

pub fn register_used_patches(&mut self, patches: &[Summary])

pub fn merge_from(&mut self, previous: &Resolve) -> CargoResult<()>

pub fn contains<Q: ?Sized>(&self, k: &Q) -> bool where
    PackageId: Borrow<Q>,
    Q: Ord + Eq, 

pub fn sort(&self) -> Vec<PackageId>

pub fn iter(&self) -> impl Iterator<Item = PackageId> + '_

pub fn deps(
    &self,
    pkg: PackageId
) -> impl Iterator<Item = (PackageId, &HashSet<Dependency>)>

pub fn deps_not_replaced(
    &self,
    pkg: PackageId
) -> impl Iterator<Item = (PackageId, &HashSet<Dependency>)>

pub fn replacement(&self, pkg: PackageId) -> Option<PackageId>

pub fn replacements(&self) -> &HashMap<PackageId, PackageId>

pub fn features(&self, pkg: PackageId) -> &[InternedString]

pub fn features_clone(&self) -> HashMap<PackageId, Vec<InternedString>>

This is only here for legacy support, it will be removed when switching to the new feature resolver.

pub fn is_public_dep(&self, pkg: PackageId, dep: PackageId) -> bool

pub fn query(&self, spec: &str) -> CargoResult<PackageId>

pub fn specs_to_ids(
    &self,
    specs: &[PackageIdSpec]
) -> CargoResult<Vec<PackageId>>

pub fn unused_patches(&self) -> &[PackageId]

pub fn checksums(&self) -> &HashMap<PackageId, Option<String>>

pub fn metadata(&self) -> &Metadata

pub fn extern_crate_name(
    &self,
    from: PackageId,
    to: PackageId,
    to_target: &Target
) -> CargoResult<String>

pub fn version(&self) -> ResolveVersion

Returns the version of the encoding that’s being used for this lock file.

pub fn set_version(&mut self, version: ResolveVersion)

pub fn summary(&self, pkg_id: PackageId) -> &Summary

Trait Implementations

impl Debug for Resolve

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

Formats the value using the given formatter.

impl PartialEq<Resolve> for Resolve

fn eq(&self, other: &Resolve) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> Serialize for Resolve

fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.