Struct BoundedLines 

pub struct BoundedLines<R> { /* private fields */ }

An AsyncRead that fails once a newline-delimited frame exceeds cap bytes.

Wraps stdin under rmcp’s own BufReader, so the counter sees the delivered chunks and not the frames: the cap is enforced as soon as the running frame passes it, without waiting for the \n that may never come. A frame of exactly cap bytes is accepted, mirroring the http side’s <= max_bytes.

The count lives here rather than in a per-receive future because rmcp keeps partial bytes across cancelled polls: receive is polled inside a select! and an in-progress line read is dropped whenever an outgoing response wins, so a per-call counter would restart mid-frame and the cap would bound nothing.

Implementations

impl<R> BoundedLines<R>

pub fn new(inner: R, cap: usize) -> Self

Bound inner to frames of at most cap bytes before the \n.

pub fn cap(&self) -> usize

The frame cap this reader enforces, in bytes before the delimiter.

Exposed so a test can assert that the stdio and http transports were sized from the same derivation rather than from two numbers that happen to agree today.

pub fn over_cap(&self) -> Arc<AtomicBool>

The trip flag, shared with whoever outlives the transport.

rmcp turns the read error into receive() -> None, which the service reports as an ordinary close (QuitReason::Closed) — so without this flag a refused frame and a peer hangup are the same Ok exit. main bails on it after waiting() so both stages exit non-zero.

Trait Implementations

impl<R: AsyncRead + Unpin> AsyncRead for BoundedLines<R>

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<()>>

Delegates the read, then measures what arrived.

Every frame in the chunk is checked at its delimiter, not only the bytes after the chunk’s last newline: a frame that both passes the cap and ends inside the tripping chunk would otherwise be seen as a short tail and let through. (Chunk length is not the measure either — many short frames may share one chunk.) Overshoot is bounded by one chunk (8 KiB under rmcp’s BufReader), since the cap can only be observed on bytes already delivered.

Bytes the tripping read delivered stay in buf; the caller drops them with the error, and the transport is closed either way.

impl<R: Debug> Debug for BoundedLines<R>

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

Formats the value using the given formatter.