Enum BufSlot 

pub enum BufSlot<B> {
    Ready(B),
    InFlight,
    Parked(B),
}

An owned buffer slot

The buffer slot threaded through poll_read_owned / poll_write_owned. It names who owns the buffer during an in-flight op, so the in-flight state is never an ambiguous None, and dropping it is always safe:

• Ready: the buffer is here, idle; read into / write from it.
• InFlight: a completion backend moved the buffer into its op-slab, the slot holds nothing. Dropping is safe, the leaf reaps it.
• Parked: a readiness backend (tokio) keeps the buffer here between polls (it has no kernel op to hold it). Nothing is DMA-ing into it, so dropping is safe too.

Usage

The consumer holds it in a persistent field, hands a buffer in once, and it is reused: tokio recycles via Ready/Parked, a completion backend registers it (InFlight) and hands it back. Construct with new, read the result via ready_mut. The buffer-carrying variants are constructed only by leaves (via park / fill), so a consumer can’t fish a buffer out mid-op.

Variants

Ready(B)

The buffer is here and idle, no op in flight, so it can be read or handed to a new op. This is both a fresh buffer and one holding a completed result, the slot tracks where the buffer is, not what’s in it.

InFlight

In flight on a completion backend, the buffer is in the leaf’s op-slab.

Parked(B)

Held by a readiness backend between polls (buffer present, mid-operation).

Implementations

impl<B> BufSlot<B>

pub fn new(buf: B) -> BufSlot<B>

A fresh slot holding buf, ready to read into / write from.

pub fn ready(&self) -> Option<&B>

The completed buffer by shared ref, only when idle (Ready, the op finished). None while a read/write is still in flight (InFlight or readiness-held Parked): a mid-operation buffer is never handed out for reading.

pub fn ready_mut(&mut self) -> Option<&mut B>

The buffer when idle (Ready), where the consumer reads the result after a completed read. None while in flight.

pub fn take_ready(self) -> Option<B>

Take the completed buffer, consuming the slot, only when idle (Ready, the op finished). None if a read/write is still in flight (InFlight or readiness-held Parked), so a caller can’t mistake a mid-operation buffer for a result. This is the normal “the read/write returned Ready, give me my buffer back” path. To recover the buffer regardless of op state, use reclaim.

pub fn reclaim(self) -> Option<B>

Recover the buffer whenever it’s present (idle Ready or readiness-held Parked), consuming the slot. None only while a completion op owns it (InFlight). For adapters that drive the poll themselves and reclaim the buffer across a Pending/Err (e.g. reusing its staging capacity, or a racing timeout short-circuiting a read): the contents may be mid-operation, so this is recovery, not result extraction, use take_ready for the latter.

pub fn is_ready(&self) -> bool

Whether the buffer is idle and here (Ready), i.e. it can be read into / written from right now. false means a read/write is still in flight (InFlight on a completion backend, Parked on a readiness one) and must be resumed via the leaf before the buffer is touched again.

pub fn take(&mut self) -> Option<B>

Take the buffer to drive an op, leaving the slot InFlight. A readiness leaf restores it with park/fill; a completion leaf leaves it InFlight until the op returns it via fill.

pub fn fill(&mut self, buf: B)

Put the buffer back as idle (a read/write completed).

pub fn park(&mut self, buf: B)

Park the buffer (a readiness backend holds it across Pending).

Trait Implementations

impl<B> Debug for BufSlot<B>

where B: Debug,

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

Formats the value using the given formatter.