Struct IndexDependency

pub struct IndexDependency {
    pub name: SmolStr,
    pub req: SmolStr,
    pub features: Box<Box<[String]>>,
    pub optional: bool,
    pub default_features: bool,
    pub target: Option<Box<SmolStr>>,
    pub kind: Option<DependencyKind>,
    pub package: Option<Box<SmolStr>>,
}

A single dependency of a specific crate version

Fields

name: SmolStr

Dependency’s arbitrary nickname (it may be an alias). Use Self::crate_name for actual crate name.

req: SmolStr

The version requirement, as a string

features: Box<Box<[String]>>

Double indirection to remove size from this struct, since the features are rarely set

optional: bool

If it is an optional dependency

default_features: bool

True if the default features are enabled

target: Option<Box<SmolStr>>

Cfg expression applied to the dependency

kind: Option<DependencyKind>

The kind of the dependency

package: Option<Box<SmolStr>>

The name of the actual crate, if it was renamed in the crate’s manifest

Implementations

impl IndexDependency

pub fn version_requirement(&self) -> VersionReq

Gets the version requirement for the dependency as a semver::VersionReq

pub fn features(&self) -> &[String]

Features unconditionally enabled when using this dependency, in addition to Self::has_default_features and features enabled through the parent crate’s feature list.

pub fn is_optional(&self) -> bool

If it’s optional, it implies a feature of its Self::name, and can be enabled through the parent crate’s features.

pub fn has_default_features(&self) -> bool

If true (default), enable default feature of this dependency

pub fn target(&self) -> Option<&str>

This dependency is only used when compiling for this cfg expression

pub fn kind(&self) -> DependencyKind

The kind of the dependency

pub fn package(&self) -> Option<&str>

Set if dependency’s crate name is different from the name (alias)

pub fn crate_name(&self) -> &str

Returns the name of the crate providing the dependency. This is equivalent to name() unless self.package() is not None, in which case it’s equal to self.package().

Basically, you can define a dependency in your Cargo.toml like this:

serde_lib = { version = "1", package = "serde" }

…which means that it uses the crate serde but imports it under the name serde_lib.

Trait Implementations

impl Clone for IndexDependency

fn clone(&self) -> IndexDependency

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IndexDependency

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IndexDependency

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for IndexDependency

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for IndexDependency

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IndexDependency

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for IndexDependency

impl StructuralPartialEq for IndexDependency