[−][src]Struct asynchronous_codec::FramedRead

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

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,` [src]

`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]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl<T, D> Deref for FramedRead<T, D>`[src]

`type Target = T`

The resulting type after dereferencing.

`pub fn deref(&self) -> &T`[src]

`impl<T, D> DerefMut for FramedRead<T, D>`[src]

`pub fn deref_mut(&mut self) -> &mut T`[src]

`impl<T, D> Stream for FramedRead<T, D> where T: AsyncRead + Unpin, D: Decoder,` [src]

`type Item = Result<D::Item, D::Error>`

Values yielded by the stream.

`pub fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>`[src]

`pub fn size_hint(&self) -> (usize, Option<usize>)`[src]

Auto Trait Implementations

`impl<T, D> RefUnwindSafe for FramedRead<T, D> where D: RefUnwindSafe, T: RefUnwindSafe,` [src]

`impl<T, D> Send for FramedRead<T, D> where D: Send, T: Send,` [src]

`impl<T, D> Sync for FramedRead<T, D> where D: Sync, T: Sync,` [src]

`impl<T, D> Unpin for FramedRead<T, D> where T: Unpin,` [src]

`impl<T, D> UnwindSafe for FramedRead<T, D> where D: UnwindSafe, T: UnwindSafe,` [src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src]

`pub fn next(&mut self) -> Next<'_, Self> where Self: Unpin,` [src]

`pub fn into_future(self) -> StreamFuture<Self> where Self: Unpin,` [src]

`pub fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src]

`pub fn enumerate(self) -> Enumerate<Self>`[src]

`pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut,` [src]

`pub fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where Fut: Future<Output = Option<T>>, F: FnMut(Self::Item) -> Fut,` [src]

`pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where Fut: Future, F: FnMut(Self::Item) -> Fut,` [src]

`pub fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src]

`pub fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src]

`pub fn cycle(self) -> Cycle<Self> where Self: Clone,` [src]

`pub fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where Fut: Future<Output = T>, F: FnMut(T, Self::Item) -> Fut,` [src]

`pub fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src]

`pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where U: Stream, F: FnMut(Self::Item) -> U,` [src]

`pub fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where Fut: Future<Output = Option>, F: FnMut(&mut S, Self::Item) -> Fut,` [src]

`pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut,` [src]

`pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut,` [src]

`pub fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where Fut: Future,` [src]

`pub fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where Fut: Future<Output = ()>, F: FnMut(Self::Item) -> Fut,` [src]

`pub fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F> where Fut: Future<Output = ()>, F: FnMut(Self::Item) -> Fut,` [src]

`pub fn take(self, n: usize) -> Take<Self>`[src]

`pub fn skip(self, n: usize) -> Skip<Self>`[src]

`pub fn fuse(self) -> Fuse<Self>`[src]

`pub fn by_ref(&mut self) -> &mut Self`[src]

`pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src]

`pub fn boxed<'a>( self ) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where Self: Send + 'a,` [src]

`pub fn boxed_local<'a>( self ) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where Self: 'a,` [src]

`pub fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future,` [src]

`pub fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future,` [src]

`pub fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream,` [src]

`pub fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>,` [src]

`pub fn peekable(self) -> Peekable<Self>`[src]

`pub fn chunks(self, capacity: usize) -> Chunks<Self>`[src]

`pub fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>`[src]

`pub fn forward<S>(self, sink: S) -> Forward<Self, S> where Self: TryStream, S: Sink<Self::Ok, Error = Self::Error>,` [src]

`pub fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>,` [src]

`pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`pub fn left_stream(self) -> Either<Self, B> where B: Stream<Item = Self::Item>,` [src]

`pub fn right_stream(self) -> Either<B, Self> where B: Stream<Item = Self::Item>,` [src]

`pub fn poll_next_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>> where Self: Unpin,` [src]

`pub fn select_next_some(&mut self) -> SelectNextSome<'_, Self> where Self: Unpin + FusedStream,` [src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<S, T, E> TryStream for S where S: Stream<Item = Result<T, E>> + ?Sized,` [src]

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`pub fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_> ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>`[src]

`impl<S> TryStreamExt for S where S: TryStream + ?Sized,` [src]

`pub fn err_into<E>(self) -> ErrInto<Self, E> where Self::Error: Into<E>,` [src]

`pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where F: FnMut(Self::Ok) -> T,` [src]

`pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where F: FnMut(Self::Error) -> E,` [src]

`pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where Fut: TryFuture<Error = Self::Error>, F: FnMut(Self::Ok) -> Fut,` [src]

`pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where Fut: TryFuture<Ok = Self::Ok>, F: FnMut(Self::Error) -> Fut,` [src]

`pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where F: FnMut(&Self::Ok),` [src]

`pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where F: FnMut(&Self::Error),` [src]

`pub fn into_stream(self) -> IntoStream<Self>`[src]

`pub fn try_next(&mut self) -> TryNext<'_, Self> where Self: Unpin,` [src]

`pub fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where Fut: TryFuture<Ok = (), Error = Self::Error>, F: FnMut(Self::Ok) -> Fut,` [src]

`pub fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where Fut: TryFuture<Ok = bool, Error = Self::Error>, F: FnMut(&Self::Ok) -> Fut,` [src]

`pub fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where Fut: TryFuture<Ok = bool, Error = Self::Error>, F: FnMut(&Self::Ok) -> Fut,` [src]

`pub fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> TryForEachConcurrent<Self, Fut, F> where Fut: Future<Output = Result<(), Self::Error>>, F: FnMut(Self::Ok) -> Fut,` [src]

`pub fn try_collect<C>(self) -> TryCollect<Self, C> where C: Default + Extend<Self::Ok>,` [src]

`pub fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Ok) -> Fut,` [src]

`pub fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where Fut: TryFuture<Ok = Option<T>, Error = Self::Error>, F: FnMut(Self::Ok) -> Fut,` [src]

`pub fn try_flatten(self) -> TryFlatten<Self> where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>,` [src]

`pub fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where Fut: TryFuture<Ok = T, Error = Self::Error>, F: FnMut(T, Self::Ok) -> Fut,` [src]

`pub fn try_concat(self) -> TryConcat<Self> where Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>, Self::Ok: IntoIterator, Self::Ok: Default,` [src]

`pub fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src]

`pub fn try_buffered(self, n: usize) -> TryBuffered<Self> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src]

`pub fn try_poll_next_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Option<Result<Self::Ok, Self::Error>>> where Self: Unpin,` [src]

`pub fn into_async_read(self) -> IntoAsyncRead<Self> where Self: TryStreamExt<Error = Error> + Unpin, Self::Ok: AsRef<[u8]>,` [src]

[−][src]Struct asynchronous_codec::FramedRead

Example

Implementations

impl<T, D> FramedRead<T, D> where T: AsyncRead, D: Decoder, [src]

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

pub fn release(self) -> (T, D)[src]

pub fn into_inner(self) -> T[src]

pub fn decoder(&self) -> &D[src]

pub fn decoder_mut(&mut self) -> &mut D[src]

pub fn read_buffer(&self) -> &BytesMut[src]

Trait Implementations

impl<T: Debug, D: Debug> Debug for FramedRead<T, D>[src]

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

impl<T, D> Deref for FramedRead<T, D>[src]

type Target = T

pub fn deref(&self) -> &T[src]

impl<T, D> DerefMut for FramedRead<T, D>[src]

pub fn deref_mut(&mut self) -> &mut T[src]

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

type Item = Result<D::Item, D::Error>

pub fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>[src]

pub fn size_hint(&self) -> (usize, Option<usize>)[src]

Auto Trait Implementations

impl<T, D> RefUnwindSafe for FramedRead<T, D> where D: RefUnwindSafe, T: RefUnwindSafe, [src]

impl<T, D> Send for FramedRead<T, D> where D: Send, T: Send, [src]

impl<T, D> Sync for FramedRead<T, D> where D: Sync, T: Sync, [src]

impl<T, D> Unpin for FramedRead<T, D> where T: Unpin, [src]

impl<T, D> UnwindSafe for FramedRead<T, D> where D: UnwindSafe, T: UnwindSafe, [src]

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<T> StreamExt for T where T: Stream + ?Sized, [src]

pub fn next(&mut self) -> Next<'_, Self> where Self: Unpin, [src]

pub fn into_future(self) -> StreamFuture<Self> where Self: Unpin, [src]

pub fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T, [src]

pub fn enumerate(self) -> Enumerate<Self>[src]

pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut, [src]

pub fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where Fut: Future<Output = Option<T>>, F: FnMut(Self::Item) -> Fut, [src]

pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where Fut: Future, F: FnMut(Self::Item) -> Fut, [src]

pub fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>, [src]

pub fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default, [src]

pub fn cycle(self) -> Cycle<Self> where Self: Clone, [src]

pub fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where Fut: Future<Output = T>, F: FnMut(T, Self::Item) -> Fut, [src]

pub fn flatten(self) -> Flatten<Self> where Self::Item: Stream, [src]

pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where U: Stream, F: FnMut(Self::Item) -> U, [src]

pub fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where Fut: Future<Output = Option<B>>, F: FnMut(&mut S, Self::Item) -> Fut, [src]

pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut, [src]

pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where Fut: Future<Output = bool>, F: FnMut(&Self::Item) -> Fut, [src]

pub fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where Fut: Future, [src]

pub fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where Fut: Future<Output = ()>, F: FnMut(Self::Item) -> Fut, [src]

pub fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F) -> ForEachConcurrent<Self, Fut, F> where Fut: Future<Output = ()>, F: FnMut(Self::Item) -> Fut, [src]

pub fn take(self, n: usize) -> Take<Self>[src]

pub fn skip(self, n: usize) -> Skip<Self>[src]

pub fn fuse(self) -> Fuse<Self>[src]

pub fn by_ref(&mut self) -> &mut Self[src]

pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe, [src]

pub fn boxed<'a>( self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where Self: Send + 'a, [src]

pub fn boxed_local<'a>( self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where Self: 'a, [src]

pub fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future, [src]

pub fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future, [src]

pub fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream, [src]

pub fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>, [src]

pub fn peekable(self) -> Peekable<Self>[src]

pub fn chunks(self, capacity: usize) -> Chunks<Self>[src]

pub fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>[src]

pub fn forward<S>(self, sink: S) -> Forward<Self, S> where Self: TryStream, S: Sink<Self::Ok, Error = Self::Error>, [src]

pub fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>, [src]

pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), [src]

pub fn left_stream<B>(self) -> Either<Self, B> where B: Stream<Item = Self::Item>, [src]

pub fn right_stream<B>(self) -> Either<B, Self> where B: Stream<Item = Self::Item>, [src]

pub fn poll_next_unpin( &mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where Self: Unpin, [src]

pub fn select_next_some(&mut self) -> SelectNextSome<'_, Self> where Self: Unpin + FusedStream, [src]