Struct asynchronous_codec::FramedRead

pub struct FramedRead<T, D> { /* private fields */ }

A Stream of messages decoded from an AsyncRead.

Example

use asynchronous_codec::{BytesCodec, FramedRead};
use futures::TryStreamExt;
use bytes::{Bytes};

let buf = [3u8; 3];
let mut framed = FramedRead::new(&buf[..], BytesCodec);

if let Some(bytes) = framed.try_next().await? {
    assert_eq!(bytes, Bytes::copy_from_slice(&buf[..]));
}

Implementations

impl<T, D> FramedRead<T, D> where
    T: AsyncRead,
    D: Decoder, 

pub fn new(inner: T, decoder: D) -> Self

Creates a new FramedRead transport with the given Decoder.

pub fn from_parts(_: FramedReadParts<T, D>) -> Self

Creates a new FramedRead from FramedReadParts.

See also FramedRead::into_parts.

pub fn into_parts(self) -> FramedReadParts<T, D>

Consumes the FramedRead, returning its parts such that a new FramedRead may be constructed, possibly with a different decoder.

See also FramedRead::from_parts.

pub fn into_inner(self) -> T

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

Note that data that has already been read but not yet consumed by the decoder is dropped. To retain any such potentially buffered data, use FramedRead::into_parts().

pub fn decoder(&self) -> &D

Returns a reference to the underlying decoder.

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

pub fn decoder_mut(&mut self) -> &mut D

Returns a mutable reference to the underlying decoder.

Note that care should be taken to not tamper with the underlying decoder 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.

Trait Implementations

impl<T: Debug, D: Debug> Debug for FramedRead<T, D>

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

Formats the value using the given formatter.

impl<T, D> Deref for FramedRead<T, D>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, D> DerefMut for FramedRead<T, D>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T, D> Stream for FramedRead<T, D> where
    T: AsyncRead + Unpin,
    D: Decoder, 

type Item = Result<D::Item, D::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.