Struct rustc_metadata::rmeta::Lazy

struct Lazy<T, Meta = Meta> where
    T: ?Sized + LazyMeta<Meta = Meta>,
    Meta: 'static + Copy,  {
    position: NonZeroUsize,
    meta: Meta,
    _marker: PhantomData<T>,
}

A value of type T referred to by its absolute position in the metadata, and which can be decoded lazily.

Metadata is effective a tree, encoded in post-order, and with the root’s position written next to the header. That means every single Lazy points to some previous location in the metadata and is part of a larger node.

The first Lazy in a node is encoded as the backwards distance from the position where the containing node starts and where the Lazy points to, while the rest use the forward distance from the previous Lazy. Distances start at 1, as 0-byte nodes are invalid. Also invalid are nodes being referred in a different order than they were encoded in.

Sequences (Lazy<[T]>)

Unlike Lazy<Vec<T>>, the length is encoded next to the position, not at the position, which means that the length doesn’t need to be known before encoding all the elements.

If the length is 0, no position is encoded, but otherwise, the encoding is that of Lazy, with the distinction that the minimal distance the length of the sequence, i.e. it’s assumed there’s no 0-byte element in the sequence.

Fields

position: NonZeroUsize

meta: Meta

_marker: PhantomData<T>

Implementations

impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<T>

fn decode<M: Metadata<'a, 'tcx>>(self, metadata: M) -> T

impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<[T]>

fn decode<M: Metadata<'a, 'tcx>>(
    self,
    metadata: M
) -> impl ExactSizeIterator<Item = T> + Captures<'a> + Captures<'tcx> + 'x

impl<I: Idx, T> Lazy<Table<I, T>> where
    Option<T>: FixedSizeEncoding, 

pub(super) fn get<'a, 'tcx, M: Metadata<'a, 'tcx>>(
    &self,
    metadata: M,
    i: I
) -> Option<T>

Given the metadata, extract out the value at a particular index (if any).

pub(super) fn size(&self) -> usize

Size of the table in entries, including possible gaps.

impl<T: ?Sized + LazyMeta> Lazy<T>

fn from_position_and_meta(position: NonZeroUsize, meta: T::Meta) -> Lazy<T>

impl<T> Lazy<T>

fn from_position(position: NonZeroUsize) -> Lazy<T>

impl<T> Lazy<[T]>

fn empty() -> Lazy<[T]>

Trait Implementations

impl<T: ?Sized + LazyMeta> Clone for Lazy<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> for Lazy<T>

fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> for Lazy<[T]>

fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx, I: Idx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> for Lazy<Table<I, T>> where
    Option<T>: FixedSizeEncoding, 

fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> for Lazy<T>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> EncodeResult

impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> for Lazy<[T]>

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> EncodeResult

impl<'a, 'tcx, I: Idx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> for Lazy<Table<I, T>> where
    Option<T>: FixedSizeEncoding, 

fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> EncodeResult

impl<T: ?Sized + LazyMeta> Copy for Lazy<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.