Struct ClientSlot 

pub struct ClientSlot {
    pub writer: RequestWriter,
    pub reader: ResponseReader,
    pub conn: Option<HttpConnection<MaybeTls>>,
}

A complete request/response pipeline: writer + reader + transport.

Each slot in the pool owns its own set of protocol primitives. Acquired via ClientPool::acquire, auto-returned on drop.

Fields are public for split borrows through Pooled<T>’s DerefMut. Deref explicitly to split, then build + send:

let s: &mut ClientSlot = &mut slot;  // explicit deref, enables split borrows
let req = s.writer.post("/order").body(json).finish()?;
let (conn, reader) = (s.conn.as_mut().unwrap(), &mut s.reader);

// With timeout (recommended for production):
let resp = tokio::time::timeout(timeout, conn.send(req, reader)).await??;

// Without timeout (prototyping only):
let resp = conn.send(req, reader).await?;

Fields

writer: RequestWriter

Request encoder (sans-IO). Build requests here.

reader: ResponseReader

Response parser. Fed by the connection during send.

conn: Option<HttpConnection<MaybeTls>>

Transport. None if connection died and needs reconnect.

Implementations

impl ClientSlot

pub fn needs_reconnect(&self) -> bool

Whether the connection is dead and needs reconnect.

pub fn conn_and_reader( &mut self, ) -> Result<(&mut HttpConnection<MaybeTls>, &mut ResponseReader), RestError>

Split borrow: get mutable references to conn + reader while writer is borrowed by a Request<'_>.

This exists because Pooled<ClientSlot> goes through DerefMut which prevents the compiler from seeing disjoint field borrows.