Enum ParticipationDiff 

pub enum ParticipationDiff {
    AllZeros(usize),
    Sparse {
        sparse_indices: Vec<u8>,
        new_values: Vec<u8>,
        extension: Vec<u8>,
    },
}

Compact delta representation for Ethereum participation flags.

The encoder selects between a dense all-zero representation and a sparse representation depending on the target vector.

This type is intended to be serialized using rkyv.

Variants

AllZeros(usize)

Represents a target participation vector containing only zero flags.

During application, the destination vector is cleared and resized to len, with every entry initialized to zero.

Sparse

Sparse representation containing only changed participation flags.

The changed indices are stored as delta-varint encoded gaps in sparse_indices. Each decoded index corresponds positionally to one value in new_values.

Fields

sparse_indices: Vec<u8>

Delta-varint encoded gaps between successive changed indices.

Starting from index zero, each decoded gap advances the current index to the next changed entry.

new_values: Vec<u8>

Replacement participation flag for each changed index.

This vector has the same number of logical entries as the decoded index sequence.

extension: Vec<u8>

Participation flags belonging to validators appended to the target vector.

Trait Implementations

impl Archive for ParticipationDiff

where usize: Archive, Vec<u8>: Archive,

type Archived = ArchivedParticipationDiff

The archived representation of this type.

type Resolver = ParticipationDiffResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for ParticipationDiff

fn clone(&self) -> ParticipationDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParticipationDiff

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<ParticipationDiff, __D> for Archived<ParticipationDiff>

where usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ParticipationDiff, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for ParticipationDiff

impl PartialEq for ParticipationDiff

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

Equality operator ==.

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

Inequality operator !=.

impl<__S: Fallible + ?Sized> Serialize<__S> for ParticipationDiff

where usize: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for ParticipationDiff