Struct Framed

pub struct Framed<IO, Codec> { /* private fields */ }

Implementations

impl<IO, Codec> Framed<IO, Codec>

pub fn new(io: IO, codec: Codec) -> Self

pub fn with_capacity(io: IO, codec: Codec, capacity: usize) -> Self

pub fn get_ref(&self) -> &IO

Returns a reference to the underlying I/O stream wrapped by Framed.

Note that care should be taken to not tamper with the underlying stream of data coming in as it may corrupt the stream of frames otherwise being worked with.

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

Returns a mutable reference to the underlying I/O stream wrapped by Framed.

Note that care should be taken to not tamper with the underlying stream of data coming in as it may corrupt the stream of frames otherwise being worked with.

pub fn codec(&self) -> &Codec

Returns a reference to the underlying codec wrapped by Framed.

Note that care should be taken to not tamper with the underlying codec as it may corrupt the stream of frames otherwise being worked with.

pub fn codec_mut(&mut self) -> &mut Codec

Returns a mutable reference to the underlying codec wrapped by Framed.

Note that care should be taken to not tamper with the underlying codec as it may corrupt the stream of frames otherwise being worked with.

pub fn map_codec<CodecNew, F>(self, map: F) -> Framed<IO, CodecNew>

where F: FnOnce(Codec) -> CodecNew,

Maps the codec U to C, preserving the read and write buffers wrapped by Framed.

Note that care should be taken to not tamper with the underlying codec as it may corrupt the stream of frames otherwise being worked with.

pub fn read_buffer(&self) -> &BytesMut

Returns a reference to the read buffer.

pub fn read_buffer_mut(&mut self) -> &mut BytesMut

Returns a mutable reference to the read buffer.

pub fn read_state_mut(&mut self) -> (&mut IO, &mut BytesMut)

Returns io and a mutable reference to the read buffer.

pub fn write_buffer(&self) -> &BytesMut

Returns a reference to the write buffer.

pub fn write_buffer_mut(&mut self) -> &mut BytesMut

Returns a mutable reference to the write buffer.

pub fn into_inner(self) -> IO

Consumes the Framed, returning its underlying I/O stream.

Note that care should be taken to not tamper with the underlying stream of data coming in as it may corrupt the stream of frames otherwise being worked with.

pub async fn next_with<C: Decoder>( &mut self, codec: &mut C, ) -> Option<Result<C::Item, C::Error>>

where IO: AsyncReadRent,

Equivalent to Stream::next but with custom codec.

pub fn peek_data(&mut self) -> impl Future<Output = Result<&mut [u8]>>

where IO: AsyncReadRent,

Await some new data. Useful to do read timeout.

pub async fn send_with<C, Item>( &mut self, codec: &mut C, item: Item, ) -> Result<(), C::Error>

where IO: AsyncWriteRent, C: Encoder<Item>,

Equivalent to Sink::send but with custom codec.

Trait Implementations

impl<IO: AsyncReadRent, Codec> AsyncReadRent for Framed<IO, Codec>

async fn read<T: IoBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Same as read(2)

async fn readv<T: IoVecBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Same as readv(2)

impl<IO: AsyncWriteRent, Codec> AsyncWriteRent for Framed<IO, Codec>

async fn write<T: IoBuf>(&mut self, buf: T) -> BufResult<usize, T>

Same as write(2)

async fn writev<T: IoVecBuf>(&mut self, buf_vec: T) -> BufResult<usize, T>

Same as writev(2)

async fn flush(&mut self) -> Result<()>

Flush buffered data if needed

async fn shutdown(&mut self) -> Result<()>

Same as shutdown

impl<T, U> Debug for Framed<T, U>

where T: Debug, U: Debug,

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

Formats the value using the given formatter.

impl<IO, Codec, Item> Sink<Item> for Framed<IO, Codec>

where IO: AsyncWriteRent, Codec: Encoder<Item>,

type Error = <FramedInner<IO, Codec, RWState> as Sink<Item>>::Error

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

async fn send(&mut self, item: Item) -> Result<(), Self::Error>

Send item.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush any remaining output from this sink.

async fn close(&mut self) -> Result<(), Self::Error>

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

impl<Codec: Encoder<Item>, IO: AsyncWriteRent, AnyCodec, Item> SinkWithCodec<Codec, Item> for Framed<IO, AnyCodec>

async fn send_with<'a>( &'a mut self, codec: &'a mut Codec, item: Item, ) -> Result<(), Codec::Error>

async fn flush(&mut self) -> Result<(), Codec::Error>

impl<IO, Codec> Stream for Framed<IO, Codec>

where IO: AsyncReadRent, Codec: Decoder,

type Item = <FramedInner<IO, Codec, RWState> as Stream>::Item

Values yielded by the stream.

async fn next(&mut self) -> 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.

impl<Codec: Decoder, IO: AsyncReadRent, AnyCodec> StreamWithCodec<Codec> for Framed<IO, AnyCodec>

type Item = Result<<Codec as Decoder>::Item, <Codec as Decoder>::Error>

async fn next_with<'a>(&'a mut self, codec: &'a mut Codec) -> Option<Self::Item>