Enum TagEncoding

pub enum TagEncoding<VariantIdx>
where
    VariantIdx: Idx,
{
    Direct,
    Niche {
        untagged_variant: VariantIdx,
        niche_variants: RangeInclusive<VariantIdx>,
        niche_start: u128,
    },
}

Variants

Direct

The tag directly stores the discriminant, but possibly with a smaller layout (so converting the tag to the discriminant can require sign extension).

Niche

Niche (values invalid for a type) encoding the discriminant: Discriminant and variant index coincide. The variant untagged_variant contains a niche at an arbitrary offset (field tag_field of the enum), which for a variant with discriminant d is set to (d - niche_variants.start).wrapping_add(niche_start) (this is wrapping arithmetic using the type of the niche field).

For example, Option<(usize, &T)> is represented such that None has a null pointer for the second tuple field, and Some is the identity function (with a non-null reference).

Other variants that are not untagged_variant and that are outside the niche_variants range cannot be represented; they must be uninhabited.

Fields

untagged_variant: VariantIdx

niche_variants: RangeInclusive<VariantIdx>

This range may contain untagged_variant; that is then just a “dead value” and not used to encode anything.

niche_start: u128

This is inbounds of the type of the niche field (not sign-extended, i.e., all bits beyond the niche field size are 0).

Trait Implementations

impl<VariantIdx> Clone for TagEncoding<VariantIdx>

where VariantIdx: Clone + Idx,

fn clone(&self) -> TagEncoding<VariantIdx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<VariantIdx> Debug for TagEncoding<VariantIdx>

where VariantIdx: Debug + Idx,

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

Formats the value using the given formatter.

impl<VariantIdx> Hash for TagEncoding<VariantIdx>

where VariantIdx: Hash + Idx,

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

where __H: Hasher,

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<VariantIdx, __CTX> HashStable<__CTX> for TagEncoding<VariantIdx>

where VariantIdx: Idx + HashStable<__CTX>, __CTX: HashStableContext,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl<VariantIdx> PartialEq for TagEncoding<VariantIdx>

where VariantIdx: PartialEq + Idx,

fn eq(&self, other: &TagEncoding<VariantIdx>) -> 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<VariantIdx> Eq for TagEncoding<VariantIdx>

where VariantIdx: Eq + Idx,

impl<VariantIdx> StructuralPartialEq for TagEncoding<VariantIdx>

where VariantIdx: Idx,

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.