Struct reqwest::RequestBuilder
[−]
[src]
pub struct RequestBuilder { /* fields omitted */ }
A builder to construct the properties of a Request
.
Methods
impl RequestBuilder
[src]
fn header<H>(&mut self, header: H) -> &mut RequestBuilder where
H: Header,
[src]
H: Header,
Add a Header
to this Request.
use reqwest::header::UserAgent; let client = reqwest::Client::new(); let res = client.get("https://www.rust-lang.org") .header(UserAgent::new("foo")) .send()?;
fn headers(&mut self, headers: Headers) -> &mut RequestBuilder
[src]
Add a set of Headers to the existing ones on this Request.
The headers will be merged in to any already set.
use reqwest::header::{Headers, UserAgent, ContentType}; fn construct_headers() -> Headers { let mut headers = Headers::new(); headers.set(UserAgent::new("reqwest")); headers.set(ContentType::png()); headers } let file = fs::File::open("much_beauty.png")?; let client = reqwest::Client::new(); let res = client.post("http://httpbin.org/post") .headers(construct_headers()) .body(file) .send()?;
fn basic_auth<U, P>(
&mut self,
username: U,
password: Option<P>
) -> &mut RequestBuilder where
U: Into<String>,
P: Into<String>,
[src]
&mut self,
username: U,
password: Option<P>
) -> &mut RequestBuilder where
U: Into<String>,
P: Into<String>,
Enable HTTP basic authentication.
let client = reqwest::Client::new(); let resp = client.delete("http://httpbin.org/delete") .basic_auth("admin", Some("good password")) .send()?;
fn body<T: Into<Body>>(&mut self, body: T) -> &mut RequestBuilder
[src]
Set the request body.
Examples
Using a string:
let client = reqwest::Client::new(); let res = client.post("http://httpbin.org/post") .body("from a &str!") .send()?;
Using a File
:
let file = fs::File::open("from_a_file.txt")?; let client = reqwest::Client::new(); let res = client.post("http://httpbin.org/post") .body(file) .send()?;
Using arbitrary bytes:
// from bytes! let bytes: Vec<u8> = vec![1, 10, 100]; let client = reqwest::Client::new(); let res = client.post("http://httpbin.org/post") .body(bytes) .send()?;
fn query<T: Serialize>(&mut self, query: &T) -> &mut 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&boo=b"
.
let client = reqwest::Client::new(); let res = client.get("http://httpbin.org") .query(&[("lang", "rust")]) .send()?;
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.
fn form<T: Serialize>(&mut self, form: &T) -> &mut RequestBuilder
[src]
Send a form body.
Sets the body to the url encoded serialization of the passed value,
and also sets the Content-Type: application/www-form-url-encoded
header.
let mut params = HashMap::new(); params.insert("lang", "rust"); let client = reqwest::Client::new(); let res = client.post("http://httpbin.org") .form(¶ms) .send()?;
Errors
This method fails if the passed value cannot be serialized into url encoded format
fn json<T: Serialize>(&mut self, json: &T) -> &mut RequestBuilder
[src]
Send a JSON body.
Sets the body to the JSON serialization of the passed value, and
also sets the Content-Type: application/json
header.
let mut map = HashMap::new(); map.insert("lang", "rust"); let client = reqwest::Client::new(); let res = client.post("http://httpbin.org") .json(&map) .send()?;
Errors
Serialization can fail if T
's implementation of Serialize
decides to
fail, or if T
contains a map with non-string keys.
fn multipart(&mut self, multipart: Form) -> &mut RequestBuilder
[src]
Sends a multipart/form-data body.
use reqwest::mime; let client = reqwest::Client::new(); let form = reqwest::multipart::Form::new() .text("key3", "value3") .file("file", "/path/to/field")?; let response = client.post("your url") .multipart(form) .send()?;
See multipart
for more examples.
fn build(&mut self) -> Result<Request>
[src]
Build a Request
, which can be inspected, modified and executed with
Client::execute()
.
Panics
This method consumes builder internal state. It panics on an attempt to reuse already consumed builder.
fn send(&mut self) -> Result<Response>
[src]
Constructs the Request and sends it the target URL, returning a Response.
Errors
This method fails if there was an error while sending request, redirect loop was detected or redirect limit was exhausted.