Struct BlobDecodeContext 

pub(super) struct BlobDecodeContext<'a> {
    opaque: MemDecoder<'a>,
    blob: &'a MetadataBlob,
    lazy_state: LazyState,
}

Decode context used when we just have a blob of metadata from which we have to decode a header and CrateRoot. After that, MetadataDecodeContext can be used. Most notably, [BlobDecodeContext] doesn’t implement SpanDecoder

Fields

opaque: MemDecoder<'a>

blob: &'a MetadataBlob

lazy_state: LazyState

Implementations

impl<'a> BlobDecodeContext<'a>

pub(crate) fn blob(&self) -> &'a MetadataBlob

fn decode_symbol_or_byte_symbol<S>( &mut self, new_from_index: impl Fn(u32) -> S, read_and_intern_str_or_byte_str_this: impl Fn(&mut Self) -> S, read_and_intern_str_or_byte_str_opaque: impl Fn(&mut MemDecoder<'a>) -> S, ) -> S

Trait Implementations

impl<'a> BlobDecoder for BlobDecodeContext<'a>

fn decode_local_def_id(&mut self) -> LocalDefId

The LocalDefId decoding logic is different from the default one (which is decoding local def id as default def id with crate num), because during metadata encoding/decoding LocalDefId is used as a wrapper around DefIndex with a guarantee that it is local, that is why we can create LocalDefId straight from a def index.

fn decode_def_index(&mut self) -> DefIndex

fn decode_symbol(&mut self) -> Symbol

fn decode_byte_symbol(&mut self) -> ByteSymbol

impl<'a> Decodable<BlobDecodeContext<'a>> for DefPathHashMapRef<'static>

fn decode(d: &mut BlobDecodeContext<'a>) -> DefPathHashMapRef<'static>

impl<'a> Decoder for BlobDecodeContext<'a>

fn read_usize(&mut self) -> usize

fn read_u128(&mut self) -> u128

fn read_u64(&mut self) -> u64

fn read_u32(&mut self) -> u32

fn read_u16(&mut self) -> u16

fn read_u8(&mut self) -> u8

fn read_isize(&mut self) -> isize

fn read_i128(&mut self) -> i128

fn read_i64(&mut self) -> i64

fn read_i32(&mut self) -> i32

fn read_i16(&mut self) -> i16

fn read_raw_bytes(&mut self, len: usize) -> &[u8]

fn peek_byte(&self) -> u8

fn position(&self) -> usize

fn read_i8(&mut self) -> i8

fn read_bool(&mut self) -> bool

fn read_char(&mut self) -> char

fn read_str(&mut self) -> &str

fn read_byte_str(&mut self) -> &[u8]

impl<'a> LazyDecoder for BlobDecodeContext<'a>

fn set_lazy_state(&mut self, state: LazyState)

fn get_lazy_state(&self) -> LazyState

fn read_lazy<T>(&mut self) -> LazyValue<T>

fn read_lazy_array<T>(&mut self, len: usize) -> LazyArray<T>

fn read_lazy_table<Ie, Id, T>( &mut self, width: usize, len: usize, ) -> LazyTable<Ie, Id, T>

fn read_lazy_offset_then<T>(&mut self, f: impl Fn(NonZero<usize>) -> T) -> T

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