Struct cargo::core::source_id::SourceId

pub struct SourceId {
    inner: &'static SourceIdInner,
}

Unique identifier for a source of packages.

Cargo uniquely identifies packages using PackageId, a combination of the package name, version, and the code source. SourceId exactly represents the “code source” in PackageId. See SourceId::hash to learn what are taken into account for the uniqueness of a source.

SourceId is usually associated with an instance of Source, which is supposed to provide a SourceId via Source::source_id method.

Fields

inner: &'static SourceIdInner

Implementations

impl SourceId

fn new(kind: SourceKind, url: Url, key: Option<KeyOf>) -> CargoResult<SourceId>

Creates a SourceId object from the kind and URL.

The canonical url will be calculated, but the precise field will not

fn wrap(inner: SourceIdInner) -> SourceId

Interns the value and returns the wrapped type.

fn remote_source_kind(url: &Url) -> SourceKind

pub fn from_url(string: &str) -> CargoResult<SourceId>

Parses a source URL and returns the corresponding ID.

Example

use cargo::core::SourceId;
SourceId::from_url("git+https://github.com/alexcrichton/\
                    libssh2-static-sys#80e71a3021618eb05\
                    656c58fb7c5ef5f12bc747f");

pub fn as_url(&self) -> SourceIdAsUrl<'_>

A view of the SourceId that can be Displayed as a URL.

pub fn as_encoded_url(&self) -> SourceIdAsUrl<'_>

Like Self::as_url but with URL parameters encoded.

pub fn for_path(path: &Path) -> CargoResult<SourceId>

Creates a SourceId from a filesystem path.

path: an absolute path.

pub fn for_git(url: &Url, reference: GitReference) -> CargoResult<SourceId>

Creates a SourceId from a Git reference.

pub fn for_registry(url: &Url) -> CargoResult<SourceId>

Creates a SourceId from a remote registry URL when the registry name cannot be determined, e.g. a user passes --index directly from CLI.

Use SourceId::for_alt_registry if a name can provided, which generates better messages for cargo.

pub fn for_alt_registry(url: &Url, key: &str) -> CargoResult<SourceId>

Creates a SourceId for a remote registry from the [registries] table or crates.io.

pub fn for_source_replacement_registry( url: &Url, key: &str, ) -> CargoResult<SourceId>

Creates a SourceId for a remote registry from the [source] replacement table.

pub fn for_local_registry(path: &Path) -> CargoResult<SourceId>

Creates a SourceId from a local registry path.

pub fn for_directory(path: &Path) -> CargoResult<SourceId>

Creates a SourceId from a directory path.

pub fn crates_io(gctx: &GlobalContext) -> CargoResult<SourceId>

Returns the SourceId corresponding to the main repository.

This is the main cargo registry by default, but it can be overridden in a .cargo/config.toml.

pub fn crates_io_maybe_sparse_http( gctx: &GlobalContext, ) -> CargoResult<SourceId>

Returns the SourceId corresponding to the main repository, using the sparse HTTP index if allowed.

pub fn crates_io_is_sparse(gctx: &GlobalContext) -> CargoResult<bool>

Returns whether to access crates.io over the sparse protocol.

pub fn alt_registry(gctx: &GlobalContext, key: &str) -> CargoResult<SourceId>

Gets the SourceId associated with given name of the remote registry.

pub fn url(&self) -> &Url

Gets this source URL.

pub fn canonical_url(&self) -> &CanonicalUrl

Gets the canonical URL of this source, used for internal comparison purposes.

pub fn display_index(self) -> String

Displays the text “crates.io index” for Cargo shell status output.

pub fn display_registry_name(self) -> String

Displays the name of a registry if it has one. Otherwise just the URL.

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

Gets the name of the remote registry as defined in the [registries] table, or the built-in crates-io key.

pub fn is_path(self) -> bool

Returns true if this source is from a filesystem path.

pub fn local_path(self) -> Option<PathBuf>

Returns the local path if this is a path dependency.

pub fn kind(&self) -> &SourceKind

pub fn is_registry(self) -> bool

Returns true if this source is from a registry (either local or not).

pub fn is_sparse(self) -> bool

Returns true if this source is from a sparse registry.

pub fn is_remote_registry(self) -> bool

Returns true if this source is a “remote” registry.

“remote” may also mean a file URL to a git index, so it is not necessarily “remote”. This just means it is not local-registry.

pub fn is_git(self) -> bool

Returns true if this source from a Git repository.

pub fn load<'a>( self, gctx: &'a GlobalContext, yanked_whitelist: &HashSet<PackageId>, ) -> CargoResult<Box<dyn Source + 'a>>

Creates an implementation of Source corresponding to this ID.

• yanked_whitelist — Packages allowed to be used, even if they are yanked.

pub fn git_reference(self) -> Option<&'static GitReference>

Gets the Git reference if this is a git source, otherwise None.

pub fn has_precise(self) -> bool

Check if the precise data field has bean set

pub fn has_locked_precise(self) -> bool

Check if the precise data field has bean set to “locked”

pub fn has_same_precise_as(self, other: Self) -> bool

Check if two sources have the same precise data field

pub fn precise_registry_version(self, pkg: &str) -> Option<(&Version, &Version)>

Check if the precise data field stores information for this name from a call to SourceId::with_precise_registry_version.

If so return the version currently in the lock file and the version to be updated to.

pub fn precise_git_fragment(self) -> Option<&'static str>

pub fn with_git_precise(self, fragment: Option<String>) -> SourceId

Creates a new SourceId from this source with the given precise.

pub fn without_precise(self) -> SourceId

Creates a new SourceId from this source without a precise.

pub fn with_locked_precise(self) -> SourceId

Creates a new SourceId from this source without a precise.

pub fn with_precise_from(self, v: Self) -> SourceId

Creates a new SourceId from this source with the precise from some other SourceId.

fn with_precise(self, precise: &Option<Precise>) -> SourceId

pub fn with_precise_registry_version( self, name: InternedString, version: Version, precise: &str, ) -> CargoResult<SourceId>

When updating a lock file on a version using cargo update --precise the requested version is stored in the precise field. On a registry dependency we also need to keep track of the package that should be updated and even which of the versions should be updated. All of this gets encoded in the precise field using this method. The data can be read with SourceId::precise_registry_version

pub fn is_crates_io(self) -> bool

Returns true if the remote registry is the standard https://crates.io.

pub fn stable_hash<S: Hasher>(self, workspace: &Path, into: &mut S)

Hashes self.

For paths, remove the workspace prefix so the same source will give the same hash in different locations, helping reproducible builds.

pub fn full_eq(self, other: SourceId) -> bool

pub fn full_hash<S: Hasher>(self, into: &mut S)

Trait Implementations

impl Clone for SourceId

fn clone(&self) -> SourceId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SourceId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SourceId

fn deserialize<D>(d: D) -> Result<SourceId, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SourceId

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

Formats the value using the given formatter.

impl Hash for SourceId

The hash of SourceId is used in the name of some Cargo folders, so shouldn’t vary. as_str gives the serialisation of a url (which has a spec) and so insulates against possible changes in how the url crate does hashing.

fn hash<S: Hasher>(&self, into: &mut S)

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 Ord for SourceId

fn cmp(&self, other: &SourceId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for SourceId

fn eq(&self, other: &SourceId) -> 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 PartialOrd for SourceId

fn partial_cmp(&self, other: &SourceId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SourceId

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for SourceId

impl Eq for SourceId

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes