Struct hyper::body::Body

#[must_use = "streams do nothing unless polled"]
pub struct Body { /* fields omitted */ }

A stream of Chunks, used when receiving bodies.

A good default Payload to use in many applications.

Methods

impl Body

pub fn empty() -> Body

Create an empty Body stream.

Example

use hyper::{Body, Request};

// create a `GET /` request
let get = Request::new(Body::empty());

pub fn channel() -> (Sender, Body)

Create a Body stream with an associated sender half.

Useful when wanting to stream chunks from another thread.

pub fn wrap_stream<S, O, E>(stream: S) -> Body where
    S: Stream<Item = Result<O, E>> + Send + Sync + 'static,
    O: Into<Chunk> + 'static,
    E: Into<Box<dyn StdError + Send + Sync>> + 'static, 

Wrap a futures Stream in a box inside Body.

Example

let chunks: Vec<Result<_, ::std::io::Error>> = vec![
    Ok("hello"),
    Ok(" "),
    Ok("world"),
];

let stream = futures_util::stream::iter(chunks);

let body = Body::wrap_stream(stream);

Unstable

This function requires enabling the unstable-stream feature in your Cargo.toml.

pub async fn next<'_>(&'_ mut self) -> Option<Result<Chunk>>

dox

Important traits for OnUpgrade

impl Future for OnUpgrade type Output = Result<Upgraded, Error>;

pub fn on_upgrade(self) -> OnUpgrade

Converts this Body into a Future of a pending HTTP upgrade.

See the upgrade module for more.

Trait Implementations

impl Default for Body

fn default() -> Body

Returns Body::empty().

impl From<Box<dyn Stream<Item = Result<Chunk, Box<dyn Error + 'static + Send + Sync>>> + 'static + Send + Sync>> for Body

Unstable

This function requires enabling the unstable-stream feature in your Cargo.toml.

fn from(
    stream: Box<dyn Stream<Item = Result<Chunk, Box<dyn StdError + Send + Sync>>> + Send + Sync>
) -> Body

Performs the conversion.

impl From<Chunk> for Body

fn from(chunk: Chunk) -> Body

Performs the conversion.

impl From<Bytes> for Body

fn from(bytes: Bytes) -> Body

Performs the conversion.

impl From<Vec<u8>> for Body

fn from(vec: Vec<u8>) -> Body

Performs the conversion.

impl From<&'static [u8]> for Body

fn from(slice: &'static [u8]) -> Body

Performs the conversion.

impl From<Cow<'static, [u8]>> for Body

fn from(cow: Cow<'static, [u8]>) -> Body

Performs the conversion.

impl From<String> for Body

fn from(s: String) -> Body

Performs the conversion.

impl From<&'static str> for Body

fn from(slice: &'static str) -> Body

Performs the conversion.

impl From<Cow<'static, str>> for Body

fn from(cow: Cow<'static, str>) -> Body

Performs the conversion.

impl Debug for Body

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

Formats the value using the given formatter.

impl Stream for Body

Unstable

This function requires enabling the unstable-stream feature in your Cargo.toml.

type Item = Result<Chunk>

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.

impl Body for Body

type Data = Chunk

Values yielded by the Body.

type Error = Error

The error type this Body might generate.

fn poll_data(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Option<Result<Self::Data, Self::Error>>>

Attempt to pull out the next data buffer of this stream.

fn poll_trailers(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<Option<HeaderMap>, Self::Error>>

Poll for an optional single HeaderMap of trailers.

fn is_end_stream(&self) -> bool

Returns true when the end of stream has been reached.

fn size_hint(&self) -> SizeHint

Returns the bounds on the remaining length of the stream.

Important traits for Next<'a, T>

impl<'a, T> Future for Next<'a, T> where
    T: Body + Unpin + ?Sized,  type Output = Option<Result<<T as Body>::Data, <T as Body>::Error>>;

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

Returns future that resolves to next data chunk, if any.

Important traits for Trailers<'a, T>

impl<'a, T> Future for Trailers<'a, T> where
    T: Body + Unpin + ?Sized,  type Output = Result<Option<HeaderMap<HeaderValue>>, <T as Body>::Error>;

fn trailers(&mut self) -> Trailers<Self> where
    Self: Unpin, 

Returns future that resolves to trailers, if any.