Struct FifoQueueDiff 

pub struct FifoQueueDiff {
    pub consumed_count: u32,
    pub appended_items: Vec<u8>,
}

Delta representation for FIFO queues.

Rather than storing the full queue, the delta records how many items were consumed from the front and the newly appended items at the back.

Fields

consumed_count: u32

The number of items consumed from the front of the base queue.

appended_items: Vec<u8>

The raw SSZ bytes of only the newly appended items at the end.

Trait Implementations

impl Archive for FifoQueueDiff

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

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.

type Archived = ArchivedFifoQueueDiff

The archived representation of this type.

type Resolver = FifoQueueDiffResolver

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::Resolver, out: Place<Self::Archived>)

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

impl Clone for FifoQueueDiff

fn clone(&self) -> FifoQueueDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FifoQueueDiff

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

Formats the value using the given formatter.

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

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<FifoQueueDiff, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for FifoQueueDiff

impl PartialEq for FifoQueueDiff

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

Equality operator ==.

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

Inequality operator !=.

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

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 FifoQueueDiff