Struct monoio_codec::FramedWrite

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

Implementations

impl<IO, Codec> FramedWrite<IO, Codec>

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

pub fn get_ref(&self) -> &IO

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

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 FramedWrite.

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 into_inner(self) -> IO

Consumes the FramedWrite, 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 fn encoder(&self) -> &Codec

Returns a reference to the underlying encoder.

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

Returns a mutable reference to the underlying encoder.

pub fn map_encoder<CodecNew, F>(self, map: F) -> FramedWrite<IO, CodecNew>where F: FnOnce(Codec) -> CodecNew,

Maps the encoder E to C, preserving the write buffer wrapped by Framed.

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.

Trait Implementations

impl<T, U> Debug for FramedWrite<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 FramedWrite<IO, Codec>where IO: AsyncWriteRent, Codec: Encoder<Item>,

type Error = <FramedInner<IO, Codec, WriteState> 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, WriteState> as Sink<Item>>::SendFuture<'a>

Future representing the send result.

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

Future representing the flush result.

type CloseFuture<'a> where Self: 'a = <FramedInner<IO, Codec, WriteState> 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.