Struct wasmbin::builtins::Lazy

pub struct Lazy<T> { /* private fields */ }

A wrapper around a type that allows it to be lazily decoded.

This is useful for types that are expensive to decode, but allowed to be skipped over by the spec (e.g. as part of a length-prefixed Blob). During decoding, this type will store the raw bytes of the value, and only decode them when explicitly requested.

When re-encoding, it will check if the value has ever been accessed mutably, and if so, re-encode it. Otherwise it will do a cheap copy of the original raw bytes.

Implementations

impl<T> Lazy<T>

pub fn from_raw(raw: UnparsedBytes) -> Self

Create a new undecoded Lazy from a raw byte vector.

pub fn try_as_raw(&self) -> Result<&UnparsedBytes, &T>

Retrieve the raw bytes if the value has not been modified yet.

impl<T: Decode> Lazy<T>

pub fn try_contents(&self) -> Result<&T, DecodeError>

Retrieve a reference to the inner value, decoding it if it wasn’t already.

pub fn try_contents_mut(&mut self) -> Result<&mut T, DecodeError>

Retrieve a mutable reference to the inner value, decoding it if it wasn’t already.

This will invalidate the original raw bytes.

pub fn try_into_contents(self) -> Result<T, DecodeError>

Unwrap the inner value, decoding it if it wasn’t already.

Trait Implementations

impl<T: Clone> Clone for Lazy<T>

fn clone(&self) -> Lazy<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Lazy<T>

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

Formats the value using the given formatter.

impl<T: Decode> Decode for Lazy<T>

fn decode(r: &mut impl Read) -> Result<Self, DecodeError>

Decodes the value from the given reader.

impl<T: Default> Default for Lazy<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Encode> Encode for Lazy<T>

fn encode(&self, w: &mut impl Write) -> Result<()>

Encodes the value into the given writer.

impl<T> From<T> for Lazy<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Decode + Hash> Hash for Lazy<T>

fn hash<H: Hasher>(&self, state: &mut H)

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<T: Decode + PartialEq> PartialEq for Lazy<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Decode + Visit> Visit for Lazy<T>

fn visit_children<'a, VisitT: 'static, E, F: FnMut(&'a VisitT) -> Result<(), E>>( &'a self, f: &mut F ) -> Result<(), VisitError<E>>

Traverse the children of this value with the provided callback.

fn visit_children_mut<VisitT: 'static, E, F: FnMut(&mut VisitT) -> Result<(), E>>( &mut self, f: &mut F ) -> Result<(), VisitError<E>>

Traverse the children of this value mutably with the provided callback.

fn visit<'a, T: 'static, R: VisitResult, F: FnMut(&'a T) -> R>( &'a self, f: F ) -> Result<(), VisitError<R::Error>>

Traverse this value with the provided callback.

fn visit_mut<T: 'static, R: VisitResult, F: FnMut(&mut T) -> R>( &mut self, f: F ) -> Result<(), VisitError<R::Error>>

Traverse this value mutably with the provided callback.

impl<T: Decode + Eq> Eq for Lazy<T>