[−][src]Struct reqwest::async::RequestBuilder

pub struct RequestBuilder { /* fields omitted */ }

A builder to construct the properties of a Request.

Methods

impl RequestBuilder[src]

pub fn header<K, V>(self, key: K, value: V) -> RequestBuilder where
    HeaderName: HttpTryFrom<K>,
    HeaderValue: HttpTryFrom<V>, [src]

Add a Header to this Request.

pub fn headers(self, headers: HeaderMap) -> RequestBuilder[src]

Add a set of Headers to the existing ones on this Request.

The headers will be merged in to any already set.

pub fn basic_auth<U, P>(
    self,
    username: U,
    password: Option<P>
) -> RequestBuilder where
    U: Display,
    P: Display, [src]

Enable HTTP basic authentication.

pub fn bearer_auth<T>(self, token: T) -> RequestBuilder where
    T: Display, [src]

Enable HTTP bearer authentication.

pub fn body<T: Into<Body>>(self, body: T) -> RequestBuilder[src]

Set the request body.

pub fn multipart(self, multipart: Form) -> RequestBuilder[src]

Sends a multipart/form-data body.



let client = reqwest::async::Client::new();
let form = reqwest::async::multipart::Form::new()
    .text("key3", "value3")
    .text("key4", "value4");

let mut rt = tokio::runtime::current_thread::Runtime::new().expect("new rt");

let response = client.post("your url")
    .multipart(form)
    .send()
    .and_then(|_| {
      Ok(())
    });

rt.block_on(response)

pub fn query<T: Serialize + ?Sized>(self, query: &T) -> RequestBuilder[src]

Modify the query string of the URL.

Modifies the URL of this request, adding the parameters provided. This method appends and does not overwrite. This means that it can be called multiple times and that existing query parameters are not overwritten if the same key is used. The key will simply show up twice in the query string. Calling .query([("foo", "a"), ("foo", "b")]) gives "foo=a&foo=b".

Note

This method does not support serializing a single key-value pair. Instead of using .query(("key", "val")), use a sequence, such as .query(&[("key", "val")]). It's also possible to serialize structs and maps into a key-value pair.

Errors

This method will fail if the object you provide cannot be serialized into a query string.

pub fn form<T: Serialize + ?Sized>(self, form: &T) -> RequestBuilder[src]

Send a form body.

pub fn json<T: Serialize + ?Sized>(self, json: &T) -> RequestBuilder[src]

Send a JSON body.

Errors

Serialization can fail if T's implementation of Serialize decides to fail, or if T contains a map with non-string keys.

pub fn build(self) -> Result<Request>[src]

Build a Request, which can be inspected, modified and executed with Client::execute().

pub fn send(self) -> impl Future<Item = Response, Error = Error>[src]

Constructs the Request and sends it to the target URL, returning a future Response.

Errors

This method fails if there was an error while sending request, redirect loop was detected or redirect limit was exhausted.

Example

let response = reqwest::r#async::Client::new()
    .get("https://hyper.rs")
    .send()
    .map(|resp| println!("status: {}", resp.status()));

let mut rt = tokio::runtime::current_thread::Runtime::new().expect("new rt");
rt.block_on(response)

Trait Implementations

impl Debug for RequestBuilder[src]

Auto Trait Implementations

impl Send for RequestBuilder

impl Unpin for RequestBuilder

impl !Sync for RequestBuilder

impl !UnwindSafe for RequestBuilder

impl !RefUnwindSafe for RequestBuilder

Blanket Implementations

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

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.

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

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

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

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

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