[−][src]Struct futures_codec::FramedRead
A Stream
of messages decoded from an AsyncRead
.
Example
use futures_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,
[src]
T: AsyncRead,
D: Decoder,
pub fn new(inner: T, decoder: D) -> Self
[src]
Creates a new FramedRead
transport with the given Decoder
.
pub fn release(self) -> (T, D)
[src]
Release the I/O and Decoder
pub fn into_inner(self) -> T
[src]
Consumes the FramedRead
, 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 decoder(&self) -> &D
[src]
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
[src]
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
[src]
Returns a reference to the read buffer.
Trait Implementations
impl<T: Debug, D: Debug> Debug for FramedRead<T, D>
[src]
impl<T, D> Deref for FramedRead<T, D>
[src]
impl<T, D> DerefMut for FramedRead<T, D>
[src]
impl<T, D> Stream for FramedRead<T, D> where
T: AsyncRead + Unpin,
D: Decoder,
[src]
T: AsyncRead + Unpin,
D: Decoder,
Auto Trait Implementations
impl<T, D> RefUnwindSafe for FramedRead<T, D> where
D: RefUnwindSafe,
T: RefUnwindSafe,
D: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, D> Send for FramedRead<T, D> where
D: Send,
T: Send,
D: Send,
T: Send,
impl<T, D> Sync for FramedRead<T, D> where
D: Sync,
T: Sync,
D: Sync,
T: Sync,
impl<T, D> Unpin for FramedRead<T, D> where
T: Unpin,
T: Unpin,
impl<T, D> UnwindSafe for FramedRead<T, D> where
D: UnwindSafe,
T: UnwindSafe,
D: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> StreamExt for T where
T: Stream + ?Sized,
[src]
T: Stream + ?Sized,
fn next(&mut self) -> Next<Self> where
Self: Unpin,
[src]
Self: Unpin,
fn into_future(self) -> StreamFuture<Self> where
Self: Unpin,
[src]
Self: Unpin,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
[src]
F: FnMut(Self::Item) -> T,
fn enumerate(self) -> Enumerate<Self>
[src]
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
[src]
C: Default + Extend<Self::Item>,
fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
[src]
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
[src]
Self::Item: Stream,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
[src]
F: FnMut(Self::Item) -> U,
U: Stream,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
[src]
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
[src]
Fut: Future,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn take(self, n: usize) -> Take<Self>
[src]
fn skip(self, n: usize) -> Skip<Self>
[src]
fn fuse(self) -> Fuse<Self>
[src]
fn by_ref(&mut self) -> &mut Self
[src]
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where
Self: Send + 'a,
[src]
Self: Send + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where
Self: 'a,
[src]
Self: 'a,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
[src]
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
[src]
Self::Item: Future,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
[src]
St: Stream,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
[src]
St: Stream<Item = Self::Item>,
fn peekable(self) -> Peekable<Self>
[src]
fn chunks(self, capacity: usize) -> Chunks<Self>
[src]
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
[src]
fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
[src]
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
[src]
Self: Sink<Item>,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>,
[src]
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>,
[src]
B: Stream<Item = Self::Item>,
fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where
Self: Unpin,
[src]
Self: Unpin,
fn select_next_some(&mut self) -> SelectNextSome<Self> where
Self: Unpin + FusedStream,
[src]
Self: Unpin + FusedStream,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
[src]
S: Stream<Item = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
[src]
self: Pin<&mut S>,
cx: &mut Context
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
[src]
S: TryStream + ?Sized,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
[src]
Self::Error: Into<E>,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
[src]
F: FnMut(Self::Ok) -> T,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
[src]
F: FnMut(Self::Error) -> E,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
[src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
[src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
[src]
F: FnMut(&Self::Ok),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
[src]
F: FnMut(&Self::Error),
fn into_stream(self) -> IntoStream<Self>
[src]
fn try_next(&mut self) -> TryNext<Self> where
Self: Unpin,
[src]
Self: Unpin,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
[src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
[src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>,
[src]
C: Default + Extend<Self::Ok>,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
[src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
[src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
[src]
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
[src]
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
[src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
[src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,