Struct hyper::proto::h1::io::Buffered

pub(crate) struct Buffered<T, B> {
    flush_pipeline: bool,
    io: T,
    read_blocked: bool,
    read_buf: BytesMut,
    read_buf_strategy: ReadStrategy,
    write_buf: WriteBuf<B>,
}

Fields

flush_pipeline: bool

io: T

read_blocked: bool

read_buf: BytesMut

read_buf_strategy: ReadStrategy

write_buf: WriteBuf<B>

Implementations

impl<T, B> Buffered<T, B>

where T: AsyncRead + AsyncWrite + Unpin, B: Buf,

pub(crate) fn new(io: T) -> Buffered<T, B>

pub(crate) fn set_flush_pipeline(&mut self, enabled: bool)

pub(crate) fn set_max_buf_size(&mut self, max: usize)

pub(crate) fn set_read_buf_exact_size(&mut self, sz: usize)

pub(crate) fn set_write_strategy_flatten(&mut self)

pub(crate) fn set_write_strategy_queue(&mut self)

pub(crate) fn read_buf(&self) -> &[u8]

fn read_buf_remaining_mut(&self) -> usize

Return the “allocated” available space, not the potential space that could be allocated in the future.

pub(crate) fn can_headers_buf(&self) -> bool

Return whether we can append to the headers buffer.

Reasons we can’t:

• The write buf is in queue mode, and some of the past body is still needing to be flushed.

pub(crate) fn headers_buf(&mut self) -> &mut Vec<u8>

pub(super) fn write_buf(&mut self) -> &mut WriteBuf<B>

pub(crate) fn buffer<BB: Buf + Into<B>>(&mut self, buf: BB)

pub(crate) fn can_buffer(&self) -> bool

pub(crate) fn consume_leading_lines(&mut self)

pub(super) fn parse<S>( &mut self, cx: &mut Context<'_>, parse_ctx: ParseContext<'_>, ) -> Poll<Result<ParsedMessage<S::Incoming>>>

where S: Http1Transaction,

pub(crate) fn poll_read_from_io( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<usize>>

pub(crate) fn into_inner(self) -> (T, Bytes)

pub(crate) fn io_mut(&mut self) -> &mut T

pub(crate) fn is_read_blocked(&self) -> bool

pub(crate) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

fn poll_flush_flattened(&mut self, cx: &mut Context<'_>) -> Poll<Result<()>>

Specialized version of flush when strategy is Flatten.

Since all buffered bytes are flattened into the single headers buffer, that skips some bookkeeping around using multiple buffers.

Trait Implementations

impl<T, B> Debug for Buffered<T, B>

where B: Buf,

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

Formats the value using the given formatter.

impl<T, B> MemRead for Buffered<T, B>

where T: AsyncRead + AsyncWrite + Unpin, B: Buf,

fn read_mem(&mut self, cx: &mut Context<'_>, len: usize) -> Poll<Result<Bytes>>

impl<T: Unpin, B> Unpin for Buffered<T, B>