Enum TagEncoding 

pub enum TagEncoding<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. Note that for this encoding, the discriminant and variant index of each variant coincide! This invariant is codified as part of layout_sanity_check.

The variant untagged_variant contains a niche at an arbitrary offset (field Variants::Multiple::tag_field of the enum). For a variant with variant index i, such that i != untagged_variant, the tag is set to (i - niche_variants.start).wrapping_add(niche_start) (this is wrapping arithmetic using the type of the niche field, cf. the tag_for_variant query implementation). To recover the variant index i from a tag, the above formula has to be reversed, i.e. i = tag.wrapping_sub(niche_start) + niche_variants.start. If i ends up outside niche_variants, the tag must have encoded the untagged_variant.

For example, Option<(usize, &T)> is represented such that the tag for None is the null pointer in the second tuple field, and Some is the identity function (with a non-null reference) and has no additional tag, i.e. the reference being non-null uniquely identifies this variant.

Other variants that are not untagged_variant and that are outside the niche_variants range cannot be represented; they must be uninhabited. Nonetheless, uninhabited variants can also fall into the range of niche_variants.

Fields

untagged_variant: VariantIdx

niche_variants: RangeInclusive<VariantIdx>

This range may contain untagged_variant or uninhabited variants; these are then just “dead values” 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 + Idx> Clone for TagEncoding<VariantIdx>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<VariantIdx: Debug + Idx> Debug for TagEncoding<VariantIdx>

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

Formats the value using the given formatter.

impl<VariantIdx: Hash + Idx> Hash for TagEncoding<VariantIdx>

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

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

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

impl<VariantIdx: PartialEq + Idx> PartialEq for TagEncoding<VariantIdx>

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 + Idx> Eq for TagEncoding<VariantIdx>

impl<VariantIdx: Idx> StructuralPartialEq for TagEncoding<VariantIdx>

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.