Struct WireReserves 

pub struct WireReserves {
    pub whole: usize,
    pub chunk: usize,
    pub min_chunk_data: usize,
}

The bytes the transport adds around a payload on the wire, per framing path. Bundled as a named value so the framing rule reads reserves.plan(len, limit) instead of a row of positional usizes, and so the production reserves live in exactly one place (WireReserves::PRODUCTION).

Fields

whole: usize

Bytes added around a whole payload — the outer TransportMessage::Custom frame.

chunk: usize

Bytes added around each chunk’s data — its MessagePayload envelope and the outer TransportMessage::Custom frame.

min_chunk_data: usize

Smallest per-chunk data payload worth producing; a limit that cannot fit chunk + min_chunk_data is rejected rather than fragmented into near-empty chunks.

Implementations

impl WireReserves

pub const PRODUCTION: WireReserves

The reserves used in production, derived from the transport/message ceilings.

pub fn plan( &self, payload_len: usize, max_message_size: usize, ) -> Option<Framing>

Frame a payload_len-byte payload for a connection whose negotiated per-message limit is max_message_size. The decision is taken against the wire bytes (payload + reserves), not the bare payload, and is a pure total function:

  plan : (len, limit) ↦ Whole                  if len + whole ≤ limit
                      ↦ Chunked(limit − chunk)  if limit ≥ chunk + min_chunk_data
                      ↦ ∅                        otherwise

∅ (None) means the peer’s limit is too small for even one useful chunk — a failure the caller surfaces, never a flood of 1-byte chunks. When Chunked { chunk_size } is returned, min_chunk_data ≤ chunk_size and chunk_size + chunk ≤ limit, so every wrapped chunk fits and a payload yields at most ⌈len / min_chunk_data⌉ chunks. Every sum is checked, so the function is total over all usize inputs (no overflow/underflow).

Trait Implementations

impl Clone for WireReserves

fn clone(&self) -> WireReserves

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for WireReserves

impl Debug for WireReserves

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

Formats the value using the given formatter.

impl Eq for WireReserves

impl PartialEq for WireReserves

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for WireReserves