Struct cargo::sources::registry::index::Summaries

struct Summaries {
    raw_data: Vec<u8>,
    versions: HashMap<Version, MaybeIndexSummary>,
}

An internal cache of summaries for a particular package.

A list of summaries are loaded from disk via one of two methods:

1. From raw registry index — Primarily Cargo will parse the corresponding file for a crate in the upstream crates.io registry. That’s just a JSON blob per line which we can parse, extract the version, and then store here. See IndexPackage and IndexSummary::parse.

2. From on-disk index cache — If Cargo has previously run, we’ll have a cached index of dependencies for the upstream index. This is a file that Cargo maintains lazily on the local filesystem and is much faster to parse since it doesn’t involve parsing all of the JSON. See SummariesCache.

The outward-facing interface of this doesn’t matter too much where it’s loaded from, but it’s important when reading the implementation to note that we try to parse as little as possible!

Fields

raw_data: Vec<u8>

A raw vector of uninterpreted bytes. This is what Unparsed start/end fields are indexes into. If a Summaries is loaded from the crates.io index then this field will be empty since nothing is Unparsed.

versions: HashMap<Version, MaybeIndexSummary>

All known versions of a crate, keyed from their Version to the possibly parsed or unparsed version of the full summary.

Implementations

impl Summaries

pub fn parse( root: &Path, cache_root: &Path, relative: &Path, source_id: SourceId, load: &mut dyn RegistryData, config: &Config ) -> Poll<CargoResult<Option<Summaries>>>

Parse out a Summaries instances from on-disk state.

This will do the followings in order:

1. Attempt to prefer parsing a previous index cache file that already exists from a previous invocation of Cargo (aka you’re typing cargo build again after typing it previously).
2. If parsing fails, or the cache isn’t found or is invalid, we then take a slower path which loads the full descriptor for relative from the underlying index (aka libgit2 with crates.io, or from a remote HTTP index) and then parse everything in there.

• root — this is the root argument passed to load
• cache_root — this is the root on the filesystem itself of where to store cache files.
• relative — this is the file we’re loading from cache or the index data
• source_id — the registry’s SourceId used when parsing JSON blobs to create summaries.
• load — the actual index implementation which may be very slow to call. We avoid this if we can.

pub fn parse_cache( contents: Vec<u8> ) -> CargoResult<(Summaries, InternedString)>

Parses the contents of an on-disk cache, aka SummariesCache, which represents information previously cached by Cargo.

Trait Implementations

impl Default for Summaries

fn default() -> Summaries

Returns the “default value” for a type.

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: 72 bytes