Struct Discriminant 

pub struct Discriminant<CVar = Vec<u8>, COff = Vec<u64>> {
    pub variant: CVar,
    pub offset: COff,
}

Tracks variant discriminants and offsets for enum containers.

Uses two arrays (variant and offset) with three states:

• Empty: both arrays empty, length is 0.
• Homogeneous: variant is empty, offset holds [tag, count] where tag = variant_index + 1. All elements share a single variant with identity offsets (element i maps to offset i).
• Heterogeneous: variant has per-element discriminants (u8), offset has per-element offsets into variant containers (u64).

Fields

variant: CVar

Per-element variant discriminants; empty when homogeneous.

offset: COff

Per-element offsets (heterogeneous), or [tag, count] (homogeneous), or empty.

Implementations

impl Discriminant

pub fn push(&mut self, variant: u8, offset: u64)

Push a variant discriminant and the offset into its variant container.

pub fn reserve_for<'a>( &mut self, selves: impl Iterator<Item = Discriminant<&'a [u8], &'a [u64]>> + Clone, )

Pre-allocate for the given borrowed discriminants.

impl<CVar: Len, COff: Len> Discriminant<CVar, COff>

pub fn is_heterogeneous(&self) -> bool

True if elements have mixed variants, with per-element discriminants and offsets.

pub fn homogeneous(&self) -> Option<u8>

where COff: IndexAs<u64>,

Returns Some(variant) if all elements share a single variant.

pub fn get(&self, index: usize) -> (u8, u64)

where CVar: IndexAs<u8>, COff: IndexAs<u64>,

Returns (variant, offset) for the element at index.

Trait Implementations

impl<'a> AsBytes<'a> for Discriminant<&'a [u8], &'a [u64]>

fn as_bytes(&self) -> impl Iterator<Item = (u64, &'a [u8])>

Presents self as a sequence of byte slices, with their required alignment.

impl Borrow for Discriminant

type Ref<'a> = (u8, u64)

For each lifetime, a reference with that lifetime.

type Borrowed<'a> = Discriminant<&'a [u8], &'a [u64]>

The type of a borrowed container.

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

Converts a reference to the type to a borrowed variant.

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

Reborrows the borrowed type to a shorter lifetime. See Columnar::reborrow for details.

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

Reborrows the borrowed type to a shorter lifetime. See Columnar::reborrow for details.

impl<CVar: Clear, COff: Clear> Clear for Discriminant<CVar, COff>

fn clear(&mut self)

Clears self, without changing its capacity.

impl<CVar: Clone, COff: Clone> Clone for Discriminant<CVar, COff>

fn clone(&self) -> Discriminant<CVar, COff>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<CVar: Debug, COff: Debug> Debug for Discriminant<CVar, COff>

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

Formats the value using the given formatter.

impl<CVar: Default, COff: Default> Default for Discriminant<CVar, COff>

fn default() -> Discriminant<CVar, COff>

Returns the “default value” for a type.

impl<'a> FromBytes<'a> for Discriminant<&'a [u8], &'a [u64]>

const SLICE_COUNT: usize

The number of byte slices this type consumes when reconstructed.

fn from_bytes(bytes: &mut impl Iterator<Item = &'a [u8]>) -> Self

Reconstructs self from a sequence of correctly aligned and sized bytes slices.

fn from_store(store: &DecodedStore<'a>, offset: &mut usize) -> Self

Reconstructs self from a DecodedStore, using direct random access at a given offset.

fn element_sizes(sizes: &mut Vec<usize>) -> Result<(), String>

Reports the element sizes (in bytes) for each slice this type consumes.

fn validate(slices: &[(&[u64], u8)]) -> Result<(), String>

where Self: Sized,

Validates that the given slices are compatible with this type.

impl<'a> Index for Discriminant<&'a [u8], &'a [u64]>

type Ref = (u8, u64)

The type returned by the get method.

fn get(&self, index: usize) -> (u8, u64)

Returns the reference type for location index.

fn last(&self) -> Option<Self::Ref>

where Self: Len,

fn index_iter(&self) -> IterOwn<&Self>

Converts &self into an iterator.

fn into_index_iter(self) -> IterOwn<Self>

where Self: Sized,

Converts self into an iterator.

impl<CVar: Len, COff: Len + IndexAs<u64>> Len for Discriminant<CVar, COff>

fn len(&self) -> usize

The number of contained elements.

fn is_empty(&self) -> bool

Whether this contains no elements.

impl<CVar: PartialEq, COff: PartialEq> PartialEq for Discriminant<CVar, COff>

fn eq(&self, other: &Discriminant<CVar, COff>) -> 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<CVar: Copy, COff: Copy> Copy for Discriminant<CVar, COff>

impl<CVar, COff> StructuralPartialEq for Discriminant<CVar, COff>