Enum SegmentationError 

#[non_exhaustive]
pub enum SegmentationError {
    ZeroSegmentSize,
    TooManySegments {
        segments: usize,
    },
    SegmentTooLarge {
        size: usize,
        max: usize,
    },
    TotalTooLarge {
        total: usize,
    },
    MissingSegment {
        index: usize,
        total: usize,
    },
    PeerSegmentLimit {
        segments: usize,
        max: u32,
    },
    PeerCannotReceive {
        capability: Segmentation,
    },
    PayloadCapacityExceeded,
    PayloadAccountingOverflow,
    NegativeAckRetriesExhausted,
    EndpointAckTooLong,
    EndpointRequestTooLong,
}

Why a payload could not be split into segments, or its segments put back together, or a segmented request sent (#1802).

It displays as segmentation error: and the variant’s text, built when displayed.

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.

ZeroSegmentSize

A segment size of 0: a segment still costs its PDU header, so a peer whose maximum APDU can’t hold that header can’t take one.

TooManySegments

The payload needs more than the 256 segments a sequence number can count.

Fields

segments: usize

Segments the payload needs.

SegmentTooLarge

A received segment larger than the receiver takes.

Fields

size: usize

The segment’s length in octets.

max: usize

The largest segment the receiver takes.

TotalTooLarge

A reassembly asked for more than 256 segments.

Fields

total: usize

The segment count asked for.

MissingSegment

A segment due in the reassembly was never received.

Fields

index: usize

The zero-based sequence number of the missing segment.

total: usize

The segment count asked for.

PeerSegmentLimit

A request needs more segments than the peer said it accepts.

Fields

segments: usize

Segments the request needs.

max: u32

The most the peer accepts.

PeerCannotReceive

A request needs segmenting and the peer advertised that it can’t receive segmented requests.

Fields

capability: Segmentation

The segmentation support the peer advertised.

PayloadCapacityExceeded

A segmented request’s octets, or its count of segments, passed the receiver’s cap.

PayloadAccountingOverflow

Counting a segmented request’s octets overflowed.

NegativeAckRetriesExhausted

The peer kept asking for the same window again with negative SegmentACKs past the sender’s retry limit.

EndpointAckTooLong

An endpoint operation’s acknowledgement is longer than the endpoint’s maximum APDU; endpoint operations don’t reassemble segments.

EndpointRequestTooLong

An endpoint request too long for one APDU; the endpoint requester doesn’t segment.

Trait Implementations

impl Clone for SegmentationError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SegmentationError

impl Debug for SegmentationError

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

Formats the value using the given formatter.

impl Display for SegmentationError

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

Formats the value using the given formatter.

impl Eq for SegmentationError

impl Error for SegmentationError

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 From<SegmentationError> for Error

fn from(error: SegmentationError) -> Self

Converts to this type from the input type.

impl Hash for SegmentationError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SegmentationError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SegmentationError