Struct cargo::core::resolver::Resolve

pub struct Resolve { /* fields omitted */ }

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, Vec<Dependency>>,
    replacements: HashMap<PackageId, PackageId>,
    features: HashMap<PackageId, HashSet<String>>,
    checksums: HashMap<PackageId, Option<String>>,
    metadata: Metadata,
    unused_patches: Vec<PackageId>,
    version: ResolveVersion
) -> Resolve

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

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<'a>(&'a self) -> impl Iterator<Item = PackageId> + 'a

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

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

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

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

pub fn features(&self, pkg: PackageId) -> &HashSet<String>

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

pub fn features_sorted(&self, pkg: PackageId) -> Vec<&str>

pub fn query(&self, spec: &str) -> CargoResult<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.

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 ==.

#[must_use]pub 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.