Struct BodyReader

pub struct BodyReader<'a> { /* private fields */ }

Available on crate feature dep_ureq only.

A reader of the response data.

1. If Transfer-Encoding: chunked, the returned reader will unchunk it and any Content-Length header is ignored.
2. If Content-Encoding: gzip (or br) and the corresponding feature flag is enabled (gzip and brotli), decompresses the body data.
3. Given a header like Content-Type: text/plain; charset=ISO-8859-1 and the charset feature enabled, will translate the body to utf-8. This mechanic need two components a mime-type starting text/ and a non-utf8 charset indication.
4. If Content-Length is set, the returned reader is limited to this byte length regardless of how many bytes the server sends.
5. If no length header, the reader is until server stream end.
6. The limit in the body method used to obtain the reader.

Note: The reader is also limited by the Body::as_reader and Body::into_reader calls. If that limit is set very high, a malicious server might return enough bytes to exhaust available memory. If you’re making requests to untrusted servers, you should use set that limit accordingly.

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);

Trait Implementations

impl<'a> Read for BodyReader<'a>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.