Enum BatchError 

#[non_exhaustive]
pub enum BatchError {
    Truncated {
        len: usize,
        need: usize,
    },
    UnsupportedVersion {
        version: u8,
    },
    EmptyBatch,
    TooManyRecords {
        count: usize,
        cap: usize,
    },
    EmptyRecord {
        index: usize,
    },
    RecordTooLarge {
        index: usize,
        len: usize,
        cap: usize,
    },
    TruncatedRecord {
        index: usize,
    },
    LengthMismatch {
        declared: usize,
        actual: usize,
    },
    PaddingNotZero {
        byte: u8,
    },
}

Why a PushBatch body or AckBatch payload could not be decoded.

Variants name the conformance-vector tags, matching CoordinateError’s convention so a non-Rust implementer can map a rejection to the vector that pins it.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Truncated

Shorter than the fixed prefix every body has.

Fields

len: usize

Bytes present.

need: usize

Bytes needed.

UnsupportedVersion

The leading version byte is one this build cannot parse.

Fields

version: u8

The version byte received.

EmptyBatch

record_count was zero. An empty batch is not a no-op to be tolerated: it is a framing disagreement, because nothing legitimate produces one.

TooManyRecords

record_count exceeds the cap in force.

Fields

count: usize

The declared count.

cap: usize

The cap.

EmptyRecord

A record inside the batch declared a zero length. The WAB cannot represent an empty record — a zero payload_len is its end-of-records sentinel — so this is rejected here rather than deeper.

Fields

index: usize

Index of the offending record.

RecordTooLarge

A record inside the batch exceeds the per-record cap. Checked per record and not only per frame, because the frame cap bounds the batch and an operator who sets max_payload_bytes is bounding a record.

Fields

index: usize

Index of the offending record.

len: usize

Its declared length.

cap: usize

The per-record cap.

TruncatedRecord

An entry’s declared length runs past the end of the body.

Fields

index: usize

Index of the offending record.

LengthMismatch

The walk consumed a different number of bytes than the body holds, or found a different number of records than record_count declared.

Both are the same class of fault: the two ends disagree about the layout. Using whichever half seems more plausible is how that disagreement turns into records silently dropped or invented.

Fields

declared: usize

What the body declared or implied.

actual: usize

What was actually found.

PaddingNotZero

A padding bit in the final bitmap byte was set.

Rejected rather than ignored, following the ReservedFlagsSet precedent: weir does not silently tolerate a set bit it has no meaning for, because the next version might give it one.

Fields

byte: u8

The offending final byte.

Trait Implementations

impl Clone for BatchError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BatchError

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

Formats the value using the given formatter.

impl Display for BatchError

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

Formats the value using the given formatter.

impl Eq for BatchError

impl Error for BatchError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for BatchError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BatchError