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.

Methods

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>
) -> 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: &HashMap<Url, Vec<Summary>>)

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

pub fn contains<Q: ?Sized>(&self, k: &Q) -> bool where
    PackageId: Borrow<Q>,
    Q: Hash + 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<'a>(
    &'a self,
    pkg: PackageId
) -> impl Iterator<Item = PackageId> + 'a

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

Trait Implementations

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: &Resolve) -> bool

This method tests for !=.

impl Debug for Resolve

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

Formats the value using the given formatter.