[−][src]Enum actix_http::body::ResponseBody

pub enum ResponseBody<B> {
    Body(B),
    Other(Body),
}

Variants

Body(B)

Other(Body)

Methods

`impl ResponseBody<Body>`[src]

`pub fn into_body(self) -> ResponseBody`[src]

`impl ResponseBody`[src]

`pub fn take_body(&mut self) -> ResponseBody`[src]

`impl<B: MessageBody> ResponseBody`[src]

`pub fn as_ref(&self) -> Option<&B>`[src]

Trait Implementations

`impl<B: MessageBody> MessageBody for ResponseBody`[src]

`fn size(&self) -> BodySize`[src]

`fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>`[src]

`impl<B: MessageBody> Stream for ResponseBody`[src]

`type Item = Bytes`

The type of item this stream will yield on success.

`type Error = Error`

The type of error this stream may generate.

`fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error>`[src]

`fn wait(self) -> Wait<Self>`[src]

`fn into_future(self) -> StreamFuture<Self>`[src]

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

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

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

`fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option,` [src]

`fn then<F, U>(self, f: F) -> Then<Self, F, U> where F: FnMut(Result<Self::Item, Self::Error>) -> U, U: IntoFuture,` [src]

`fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where F: FnMut(Self::Item) -> U, U: IntoFuture<Error = Self::Error>,` [src]

`fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where F: FnMut(Self::Error) -> U, U: IntoFuture<Item = Self::Item>,` [src]

`fn collect(self) -> Collect<Self>`[src]

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

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

`fn fold<F, T, Fut>(self, init: T, f: F) -> Fold<Self, F, Fut, T> where F: FnMut(T, Self::Item) -> Fut, Fut: IntoFuture<Item = T>, Self::Error: From<<Fut as IntoFuture>::Error>,` [src]

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

`fn skip_while<P, R>(self, pred: P) -> SkipWhile<Self, P, R> where P: FnMut(&Self::Item) -> R, R: IntoFuture<Item = bool, Error = Self::Error>,` [src]

`fn take_while<P, R>(self, pred: P) -> TakeWhile<Self, P, R> where P: FnMut(&Self::Item) -> R, R: IntoFuture<Item = bool, Error = Self::Error>,` [src]

`fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where F: FnMut(Self::Item) -> U, U: IntoFuture<Item = (), Error = Self::Error>,` [src]

`fn from_err<E>(self) -> FromErr<Self, E> where E: From<Self::Error>,` [src]

`fn take(self, amt: u64) -> Take<Self>`[src]

`fn skip(self, amt: u64) -> 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]

`fn buffered(self, amt: usize) -> Buffered<Self> where Self::Item: IntoFuture, <Self::Item as IntoFuture>::Error == Self::Error,` [src]

`fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where Self::Item: IntoFuture, <Self::Item as IntoFuture>::Error == Self::Error,` [src]

`fn merge<S>(self, other: S) -> Merge<Self, S> where S: Stream<Error = Self::Error>,` [src]

`fn zip<S>(self, other: S) -> Zip<Self, S> where S: Stream<Error = Self::Error>,` [src]

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

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

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

`fn select<S>(self, other: S) -> Select<Self, S> where S: Stream<Item = Self::Item, Error = Self::Error>,` [src]

`fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<SinkItem = Self::Item>, Self::Error: From<<S as Sink>::SinkError>,` [src]

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

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

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

Auto Trait Implementations

`impl !Send for ResponseBody`

`impl !Sync for ResponseBody`

`impl Unpin for ResponseBody where B: Unpin,`

`impl !UnwindSafe for ResponseBody`

`impl !RefUnwindSafe for ResponseBody`

Blanket Implementations

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

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

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

`fn from(t: T) -> T`[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.

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

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

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

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

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

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

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

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

`impl<T> IntoStream for T where T: Stream,` [src]

`type Item = <T as Stream>::Item`

`type Error = <T as Stream>::Error`

`type Stream = T`

`fn into_stream(self) -> <T as IntoStream>::Stream`[src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`fn vzip(self) -> V`

[−][src]Enum actix_http::body::ResponseBody

Variants

Methods

impl ResponseBody<Body>[src]

pub fn into_body<B>(self) -> ResponseBody<B>[src]

impl<B> ResponseBody<B>[src]

pub fn take_body(&mut self) -> ResponseBody<B>[src]

impl<B: MessageBody> ResponseBody<B>[src]

pub fn as_ref(&self) -> Option<&B>[src]

Trait Implementations

impl<B: MessageBody> MessageBody for ResponseBody<B>[src]

fn size(&self) -> BodySize[src]

fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>[src]

impl<B: MessageBody> Stream for ResponseBody<B>[src]

type Item = Bytes

type Error = Error

fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error>[src]

fn wait(self) -> Wait<Self>[src]

fn into_future(self) -> StreamFuture<Self>[src]

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

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

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

fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>, [src]

fn then<F, U>(self, f: F) -> Then<Self, F, U> where F: FnMut(Result<Self::Item, Self::Error>) -> U, U: IntoFuture, [src]

fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where F: FnMut(Self::Item) -> U, U: IntoFuture<Error = Self::Error>, [src]

fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where F: FnMut(Self::Error) -> U, U: IntoFuture<Item = Self::Item>, [src]

fn collect(self) -> Collect<Self>[src]

fn concat2(self) -> Concat2<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default, [src]

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

fn fold<F, T, Fut>(self, init: T, f: F) -> Fold<Self, F, Fut, T> where F: FnMut(T, Self::Item) -> Fut, Fut: IntoFuture<Item = T>, Self::Error: From<<Fut as IntoFuture>::Error>, [src]

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

fn skip_while<P, R>(self, pred: P) -> SkipWhile<Self, P, R> where P: FnMut(&Self::Item) -> R, R: IntoFuture<Item = bool, Error = Self::Error>, [src]

fn take_while<P, R>(self, pred: P) -> TakeWhile<Self, P, R> where P: FnMut(&Self::Item) -> R, R: IntoFuture<Item = bool, Error = Self::Error>, [src]

fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where F: FnMut(Self::Item) -> U, U: IntoFuture<Item = (), Error = Self::Error>, [src]

fn from_err<E>(self) -> FromErr<Self, E> where E: From<Self::Error>, [src]

fn take(self, amt: u64) -> Take<Self>[src]

fn skip(self, amt: u64) -> 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]

fn buffered(self, amt: usize) -> Buffered<Self> where Self::Item: IntoFuture, <Self::Item as IntoFuture>::Error == Self::Error, [src]

fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where Self::Item: IntoFuture, <Self::Item as IntoFuture>::Error == Self::Error, [src]

fn merge<S>(self, other: S) -> Merge<Self, S> where S: Stream<Error = Self::Error>, [src]

fn zip<S>(self, other: S) -> Zip<Self, S> where S: Stream<Error = Self::Error>, [src]

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

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

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

fn select<S>(self, other: S) -> Select<Self, S> where S: Stream<Item = Self::Item, Error = Self::Error>, [src]

fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<SinkItem = Self::Item>, Self::Error: From<<S as Sink>::SinkError>, [src]

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

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

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

Auto Trait Implementations

impl<B> !Send for ResponseBody<B>

impl<B> !Sync for ResponseBody<B>

impl<B> Unpin for ResponseBody<B> where B: Unpin,

impl<B> !UnwindSafe for ResponseBody<B>

impl<B> !RefUnwindSafe for ResponseBody<B>

Blanket Implementations

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

fn into(self) -> U[src]

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

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

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

type Error = Infallible

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]

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

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

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

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

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

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

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

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

impl<T> IntoStream for T where T: Stream, [src]

type Item = <T as Stream>::Item

type Error = <T as Stream>::Error

type Stream = T

fn into_stream(self) -> <T as IntoStream>::Stream[src]