Struct h2::RecvStream[−][src]

pub struct RecvStream { /* fields omitted */ }

Expand description

Receives the body stream and trailers from the remote peer.

A RecvStream is provided by client::ResponseFuture and server::Connection with the received HTTP/2.0 message head (the response and request head respectively).

A RecvStream instance is used to receive the streaming message body and any trailers from the remote peer. It is also used to manage inbound flow control.

See method level documentation for more details on receiving data. See FlowControl for more details on inbound flow control.

Struct h2::RecvStream[−][src]

Implementations

impl RecvStream

pub async fn data(&mut self) -> Option<Result<Bytes, Error>>

pub async fn trailers(&mut self) -> Result<Option<HeaderMap>, Error>

pub fn poll_data( &mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>>

pub fn is_end_stream(&self) -> bool

pub fn flow_control(&mut self) -> &mut FlowControl

pub fn stream_id(&self) -> StreamId

Panics

Trait Implementations

impl Debug for RecvStream

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

impl Drop for RecvStream

fn drop(&mut self)

impl Stream for RecvStream

type Item = Result<Bytes, Error>

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

fn size_hint(&self) -> (usize, Option<usize>)

Auto Trait Implementations

impl RefUnwindSafe for RecvStream

impl Send for RecvStream

impl Sync for RecvStream

impl Unpin for RecvStream

impl UnwindSafe for RecvStream

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

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

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

fn into_future(self) -> StreamFuture<Self> where Self: Unpin,

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

fn enumerate(self) -> Enumerate<Self>

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where 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>>,

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

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

fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where Self: Stream<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>,

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

fn cycle(self) -> Cycle<Self> where Self: Clone,

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>,

fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>,

fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = bool>,

fn flatten(self) -> Flatten<Self> where Self::Item: Stream,

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

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>>,

fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where 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>,

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

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

fn take(self, n: usize) -> Take<Self>

fn skip(self, n: usize) -> Skip<Self>

fn fuse(self) -> Fuse<Self>

fn by_ref(&mut self) -> &mut Self

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

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

fn peekable(self) -> Peekable<Self>

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

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

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

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

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

impl<T, U> TryFrom<U> for T where U: Into<T>,

type Error = Infallible

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

impl<T, U> TryInto<U> for T where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

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

pub fn poll_data(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Bytes, Error>>>

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

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

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T, U> Into<U> for T where
U: From<T>,

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

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

fn into_future(self) -> StreamFuture<Self> where
Self: Unpin,

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

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
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>>,

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

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

fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,

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

fn cycle(self) -> Cycle<Self> where
Self: Clone,

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>,

fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,

fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,

fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,

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

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>>,

fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
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>,

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

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

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

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

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

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

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

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

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

impl<T, U> TryFrom<U> for T where
U: Into<T>,

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

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

pub fn try_poll_next(
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,

fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,

fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,

fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
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>,

fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
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),

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),

fn try_next(&mut self) -> TryNext<'_, Self> where
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>,

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>,

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

fn try_collect<C>(self) -> TryCollect<Self, C> where
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>,

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>,

fn try_flatten(self) -> TryFlatten<Self> where
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>,

fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,

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