Enum Discriminator 

pub enum Discriminator {
    Known(VariantId),
    Invalid,
    Branch {
        offset: ByteCount,
        int_ty: IntegerTy,
        children: Vec<(RangeInclusive<ScalarValue>, Discriminator)>,
        fallback: Box<Discriminator>,
    },
}

Decision tree used to determine the active variant by reading memory. Mirrors MiniRust’s Discriminator.

Variants

Known(VariantId)

The variant is known.

Invalid

No valid variant (e.g., invalid tag value).

Branch

Branch on an integer value read from memory at offset.

Fields

offset: ByteCount

Byte offset to read from.

int_ty: IntegerTy

Integer type to read.

children: Vec<(RangeInclusive<ScalarValue>, Discriminator)>

If the integer is in one of these ranges, continue with the given Discriminator. The ranges are sorted.

fallback: Box<Discriminator>

Fallback if no range in children matches.

Implementations

impl Discriminator

pub fn trivial(variant_id: VariantId) -> Self

Make a trivial discriminator that always returns the given variant id.

pub fn read_discriminant( &self, read: impl Fn(ByteCount, IntegerTy) -> Result<ScalarValue, DiscriminantReadError> + Copy, ) -> Result<VariantId, DiscriminantReadError>

Read a discriminant from memory. The read function simulates reading an integer of the given type at the given byte offset from memory and can return UninitByte if the byte could not be read.

Trait Implementations

impl Clone for Discriminator

fn clone(&self) -> Discriminator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Discriminator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Discriminator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Discriminator

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Discriminator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Discriminator

impl StructuralPartialEq for Discriminator