Struct Body

source

pub struct Body { /* private fields */ }

Expand description

A response body returned as http::Response<Body>.

§Example

use std::io::Read;
let mut res = ureq::get("http://httpbin.org/bytes/100")
    .call()?;

assert!(res.headers().contains_key("Content-Length"));
let len: usize = res.headers().get("Content-Length")
    .unwrap().to_str().unwrap().parse().unwrap();

let mut bytes: Vec<u8> = Vec::with_capacity(len);
res.body_mut().as_reader()
    .read_to_end(&mut bytes)?;

assert_eq!(bytes.len(), len);

Implementations§

source §

impl Body

source

pub fn builder() -> BodyBuilder

Builder for creating a body

This is useful for testing, or for Middleware that returns another body than the requested one.

source

pub fn mime_type(&self) -> Option<&str>

The mime-type of the content-type header.

For the below header, we would get Some("text/plain"):

    Content-Type: text/plain; charset=iso-8859-1

§Example

let res = ureq::get("https://www.google.com/")
    .call()?;

assert_eq!(res.body().mime_type(), Some("text/html"));

source

pub fn charset(&self) -> Option<&str>

The charset of the content-type header.

For the below header, we would get Some("iso-8859-1"):

    Content-Type: text/plain; charset=iso-8859-1

§Example

let res = ureq::get("https://www.google.com/")
    .call()?;

assert_eq!(res.body().charset(), Some("ISO-8859-1"));

source

pub fn as_reader(&mut self) -> BodyReader<'_> ⓘ

Handle this body as a shared impl Read of the body.

This is the regular API which goes via http::Response::body_mut() to get a mut reference to the Body, and then use as_reader(). It is also possible to get a non-shared, owned reader via Body::into_reader().

Reader is not limited. To set a limit use Body::with_config().

§Example

use std::io::Read;

let mut res = ureq::get("http://httpbin.org/bytes/100")
    .call()?;

let mut bytes: Vec<u8> = Vec::with_capacity(1000);
res.body_mut().as_reader()
    .read_to_end(&mut bytes)?;

source

pub fn into_reader(self) -> BodyReader<'static> ⓘ

Turn this response into an owned impl Read of the body.

Sometimes it might be useful to disconnect the body reader from the body. The reader returned by Body::as_reader() borrows the body, while this variant consumes the body and turns it into a reader with lifetime 'static. The reader can for instance be sent to another thread.

Reader is not limited. To set a limit use Body::into_with_config().

use std::io::Read;

let res = ureq::get("http://httpbin.org/bytes/100")
    .call()?;

let (_, body) = res.into_parts();

let mut bytes: Vec<u8> = Vec::with_capacity(1000);
body.into_reader()
    .read_to_end(&mut bytes)?;

source

pub fn read_to_string(&mut self) -> Result<String, Error>

Read the response as a string.

Response is limited to 10MB
Replaces incorrect utf-8 chars to ?

To change these defaults use Body::with_config().

let mut res = ureq::get("http://httpbin.org/robots.txt")
    .call()?;

let s = res.body_mut().read_to_string()?;
assert_eq!(s, "User-agent: *\nDisallow: /deny\n");

source

pub fn read_to_vec(&mut self) -> Result<Vec<u8>, Error>

Read the response to a vec.

Response is limited to 10MB.

To change this default use Body::with_config().

let mut res = ureq::get("http://httpbin.org/bytes/100")
    .call()?;

let bytes = res.body_mut().read_to_vec()?;
assert_eq!(bytes.len(), 100);

source

pub fn read_json<T: DeserializeOwned>(&mut self) -> Result<T, Error>

Read the response from JSON.

Response is limited to 10MB.

To change this default use Body::as_reader() and deserialize JSON manually.

The returned value is something that derives Deserialize. You might need to be explicit with which type you want. See example below.

use serde::Deserialize;

#[derive(Deserialize)]
struct BodyType {
  slideshow: BodyTypeInner,
}

#[derive(Deserialize)]
struct BodyTypeInner {
  author: String,
}

let body = ureq::get("https://httpbin.org/json")
    .call()?
    .body_mut()
    .read_json::<BodyType>()?;

assert_eq!(body.slideshow.author, "Yours Truly");

source

pub fn with_config(&mut self) -> BodyWithConfig<'_>

Read the body data with configuration.

This borrows the body which gives easier use with http::Response::body_mut(). To get a non-borrowed reader use Body::into_with_config().

§Example

let reader = ureq::get("http://httpbin.org/bytes/100")
    .call()?
    .body_mut()
    .with_config()
    // Reader will only read 50 bytes
    .limit(50)
    .reader();

source

pub fn into_with_config(self) -> BodyWithConfig<'static>

Consume self and read the body with configuration.

This consumes self and returns a reader with 'static lifetime.

§Example

// Get the body out of http::Response
let (_, body) = ureq::get("http://httpbin.org/bytes/100")
    .call()?
    .into_parts();

let reader = body
    .into_with_config()
    // Reader will only read 50 bytes
    .limit(50)
    .reader();