Enum QueueDiff 

pub enum QueueDiff {
    Fifo {
        consumed_count: u32,
        appended_items: Vec<u8>,
    },
    FullReplacement(Vec<u8>),
}

Universal delta representation for SSZ-serialized queue-like lists.

The representation supports both:

• FIFO transitions, where items are consumed from the front and appended at the back; and
• safe fallback to complete replacement when the FIFO assumptions cannot be established.

The FIFO representation stores raw SSZ bytes rather than deserializing individual queue items.

Variants

Fifo

Validated FIFO transition.

The base queue loses consumed_count items from its front and receives appended_items at its back.

Fields

consumed_count: u32

Number of complete queue items consumed from the front.

appended_items: Vec<u8>

Raw SSZ bytes of items appended to the target queue.

FullReplacement(Vec<u8>)

Complete replacement of the serialized target queue.

This is used when the queue cannot safely be represented as a FIFO transition.

Trait Implementations

impl Archive for QueueDiff

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

type Archived = ArchivedQueueDiff

The archived representation of this type.

type Resolver = QueueDiffResolver

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 QueueDiff

fn clone(&self) -> QueueDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueueDiff

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

Formats the value using the given formatter.

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

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

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

Deserializes using the given deserializer

impl Eq for QueueDiff

impl PartialEq for QueueDiff

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

Equality operator ==.

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

Inequality operator !=.

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

where u32: 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 QueueDiff