Enum ParticipationDiff 

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

Compact delta encoding for participation flags.

A participation delta stores only the information required to transform one participation vector into another.

The encoder automatically selects the most compact representation:

• ParticipationDiff::AllZeros when the target vector contains only zero-valued flags.
• ParticipationDiff::Sparse when only a subset of indices change.

This type is intended to be serialized using rkyv.

Variants

AllZeros(usize)

Represents a participation vector consisting entirely of zeros.

During reconstruction the destination vector is resized to len and every entry is set to 0.

Sparse

Sparse delta representation.

Only indices whose values differ from the base vector are stored.

Changed indices are encoded as delta-varint gaps to reduce storage requirements for sparsely changing participation flags.

Fields

sparse_indices: Vec<u8>

Delta-varint encoded gaps between successive modified indices.

Each decoded gap is added to the previous modified index to recover the absolute index.

new_values: Vec<u8>

Replacement participation flags.

Each entry corresponds one-to-one with a decoded index from sparse_indices.

extension: Vec<u8>

Participation flags for validators that exist only in 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