Struct h2::codec::Codec

pub struct Codec<T, B> {
    inner: FramedRead<FramedWrite<T, B>>,
}

Fields

inner: FramedRead<FramedWrite<T, B>>

Implementations

impl<T, B> Codec<T, B>

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

pub fn new(io: T) -> Self

Returns a new Codec with the default max frame size

pub fn with_max_recv_frame_size(io: T, max_frame_size: usize) -> Self

Returns a new Codec with the given maximum frame size

impl<T, B> Codec<T, B>

pub fn set_max_recv_frame_size(&mut self, val: usize)

Updates the max received frame size.

The change takes effect the next time a frame is decoded. In other words, if a frame is currently in process of being decoded with a frame size greater than val but less than the max frame size in effect before calling this function, then the frame will be allowed.

pub fn max_send_frame_size(&self) -> usize

Returns the max frame size that can be sent to the peer.

pub fn set_max_send_frame_size(&mut self, val: usize)

Set the peer’s max frame size.

pub fn set_send_header_table_size(&mut self, val: usize)

Set the peer’s header table size size.

pub fn set_recv_header_table_size(&mut self, val: usize)

Set the decoder header table size size.

pub fn set_max_recv_header_list_size(&mut self, val: usize)

Set the max header list size that can be received.

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the inner stream.

pub(crate) fn take_last_data_frame(&mut self) -> Option<Data<B>>

Takes the data payload value that was fully written to the socket

fn framed_write(&mut self) -> &mut FramedWrite<T, B>

impl<T, B> Codec<T, B>

where T: AsyncWrite + Unpin, B: Buf,

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

Returns Ready when the codec can buffer a frame

pub fn buffer(&mut self, item: Frame<B>) -> Result<(), UserError>

Buffer a frame.

poll_ready must be called first to ensure that a frame may be accepted.

TODO: Rename this to avoid conflicts with Sink::buffer

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

Flush buffered data to the wire

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

Shutdown the send half

Trait Implementations

impl<T: Debug, B: Debug> Debug for Codec<T, B>

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

Formats the value using the given formatter.

impl<T> From<T> for Codec<T, Bytes>

where T: AsyncRead + AsyncWrite + Unpin,

fn from(src: T) -> Self

Converts to this type from the input type.

impl<T, B> Sink<Frame<B>> for Codec<T, B>

where T: AsyncWrite + Unpin, B: Buf,

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Returns Ready when the codec can buffer a frame

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush buffered data to the wire

type Error = SendError

The type of value produced by the sink when an error occurs.

fn start_send(self: Pin<&mut Self>, item: Frame<B>) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T, B> Stream for Codec<T, B>

where T: AsyncRead + Unpin,

type Item = Result<Frame, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.