## EncodedDepInfo

# Struct EncodedDepInfo

Source

    pub struct EncodedDepInfo {
        pub files: Vec<(DepInfoPathType, PathBuf, Option<(u64, String)>)>,
        pub env: Vec<(String, Option<String>)>,
    }

Expand description

Same as `RustcDepInfo` except avoids absolute paths as much as possible to allow moving around the target directory.

This is also stored in an optimized format to make parsing it fast because Cargo will read it for crates on all future compilations.

Currently the format looks like:

    +--------+---------+------------+------------+---------------+---------------+
    | marker | version | # of files | file paths | # of env vars | env var pairs |
    +--------+---------+------------+------------+---------------+---------------+

Each field represents

- Marker — A magic marker to ensure that older Cargoes, which only recognize format v0 (prior to checksum support in `f4ca7390`), do not proceed with parsing newer formats. Since `EncodedDepInfo` is merely an optimization, and to avoid adding complexity, Cargo recognizes only one version of `CURRENT_ENCODED_DEP_INFO_VERSION`. The current layout looks like this

      +----------------------------+
      | [0x01 0x00 0x00 0x00 0xff] |
      +----------------------------+

  These bytes will be interpreted as “one file tracked and an invalid `DepInfoPathType` variant with 255” by older Cargoes, causing them to stop parsing. This could prevent problematic parsing as noted in rust-lang/cargo#14712.

- Version — The current format version.

- Number of files/envs — A `u32` representing the number of things.

- File paths — Zero or more paths of files the dep-info file depends on. Each path is encoded as the following:

      +-----------+-------------+------------+---------------+-----------+-------+
      | path type | len of path | path bytes | cksum exists? | file size | cksum |
      +-----------+-------------+------------+---------------+-----------+-------+

- Env var pairs — Zero or more env vars the dep-info file depends on. Each env key-value pair is encoded as the following:

      +------------+-----------+---------------+--------------+-------------+
      | len of key | key bytes | value exists? | len of value | value bytes |
      +------------+-----------+---------------+--------------+-------------+

## Fields§

§`files: Vec<(DepInfoPathType, PathBuf, Option<(u64, String)>)>`§`env: Vec<(String, Option<String>)>`

## Implementations§

Source§

### impl EncodedDepInfo

Source

#### pub fn parse(bytes: &[u8]) -> Option<EncodedDepInfo>

Source

#### pub fn serialize(&self) -> CargoResult<Vec<u8>>

## Trait Implementations§

Source§

### impl Debug for EncodedDepInfo

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl Default for EncodedDepInfo

Source§

#### fn default() -> EncodedDepInfo

Returns the “default value” for a type. Read more
Source§

### impl PartialEq for EncodedDepInfo

Source§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

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

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

### impl Eq for EncodedDepInfo

Source§

### impl StructuralPartialEq for EncodedDepInfo

## Auto Trait Implementations§

§

### impl Freeze for EncodedDepInfo

§

### impl RefUnwindSafe for EncodedDepInfo

§

### impl Send for EncodedDepInfo

§

### impl Sync for EncodedDepInfo

§

### impl Unpin for EncodedDepInfo

§

### impl UnwindSafe for EncodedDepInfo

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [`Span`], returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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: 48 bytes