Struct monoio_codec::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 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.

Trait Implementations

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<Codec: Decoder, IO: AsyncReadRent, AnyCodec> NextWithCodec<Codec> for Framed<IO, AnyCodec>

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

type NextFuture<'a> where Self: 'a, Codec: 'a = impl Future<Output = Option<<Framed<IO, AnyCodec> as NextWithCodec<Codec>>::Item>> + 'a

fn next_with<'a>(&'a mut self, codec: &'a mut Codec) -> Self::NextFuture<'_>

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.

type SendFuture<'a> where Self: 'a, Item: 'a = <FramedInner<IO, Codec, RWState> as Sink<Item>>::SendFuture<'a>

Future representing the send result.

type FlushFuture<'a> where Self: 'a = <FramedInner<IO, Codec, RWState> as Sink<Item>>::FlushFuture<'a>

Future representing the flush result.

type CloseFuture<'a> where Self: 'a = <FramedInner<IO, Codec, RWState> as Sink<Item>>::CloseFuture<'a>

Future representing the close result.

fn send<'a>(&'a mut self, item: Item) -> Self::SendFuture<'a>where Item: 'a,

Send item.

fn flush(&mut self) -> Self::FlushFuture<'_>

Flush any remaining output from this sink.

fn close(&mut self) -> Self::CloseFuture<'_>

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

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.

type NextFuture<'a> where Self: 'a = <FramedInner<IO, Codec, RWState> as Stream>::NextFuture<'a>

Future representing the next value of the stream.

fn next(&mut self) -> Self::NextFuture<'_>

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.