[−][src]Struct tide::Response

pub struct Response { /* fields omitted */ }

An HTTP response

Implementations

`impl Response`[src]

`#[must_use]pub fn new<S>(status: S) -> Self where S: TryInto<StatusCode>, S::Error: Debug,` [src]

Create a new instance.

`#[must_use]pub fn builder<S>(status: S) -> ResponseBuilder where S: TryInto<StatusCode>, S::Error: Debug,` [src]

Begin a chained response builder. For more details, see ResponseBuilder

Example:

let mut response = Response::builder(203)
    .body("<html>hi</html>")
    .header("custom-header", "value")
    .content_type(mime::HTML)
    .build();

assert_eq!(response.take_body().into_string().await.unwrap(), "<html>hi</html>");
assert_eq!(response.status(), StatusCode::NonAuthoritativeInformation);
assert_eq!(response["custom-header"], "value");
assert_eq!(response["content-type"], "text/html;charset=utf-8");

`#[must_use]pub fn status(&self) -> StatusCode`[src]

Returns the http status code.

`pub fn set_status<S>(&mut self, status: S) where S: TryInto<StatusCode>, S::Error: Debug,` [src]

Set the http status code.

Example:

let mut response = Response::new(StatusCode::Ok);

response.set_status(418); // the status can be a valid u16 http status code
assert_eq!(response.status(), StatusCode::ImATeapot);

response.set_status(StatusCode::NonAuthoritativeInformation); // or a tide::StatusCode
assert_eq!(response.status(), StatusCode::NonAuthoritativeInformation);

Panics

set_status will panic if the status argument cannot be successfully converted into a StatusCode.

Response::new(200).set_status(210); // this is not an established status code and will panic

`#[must_use]pub fn len(&self) -> Option<usize>`[src]

Get the length of the body.

`#[must_use]pub fn is_empty(&self) -> Option<bool>`[src]

Checks if the body is empty.

`#[must_use]pub fn header(&self, name: impl Into<HeaderName>) -> Option<&HeaderValues>`[src]

Get an HTTP header.

`#[must_use]pub fn header_mut( &mut self, name: impl Into<HeaderName> ) -> Option<&mut HeaderValues>`[src]

Get an HTTP header mutably.

`pub fn remove_header( &mut self, name: impl Into<HeaderName> ) -> Option<HeaderValues>`[src]

Remove a header.

`pub fn insert_header( &mut self, key: impl Into<HeaderName>, value: impl ToHeaderValues )`[src]

Insert an HTTP header.

`pub fn append_header( &mut self, key: impl Into<HeaderName>, value: impl ToHeaderValues )`[src]

Append an HTTP header.

`#[must_use]pub fn iter(&self) -> Iter<'_>ⓘNotable traits for Iter<'a> impl<'a> Iterator for Iter<'a> type Item = (&'a HeaderName, &'a HeaderValues);`[src]

An iterator visiting all header pairs in arbitrary order.

`#[must_use]pub fn iter_mut(&mut self) -> IterMut<'_>ⓘNotable traits for IterMut<'a> impl<'a> Iterator for IterMut<'a> type Item = (&'a HeaderName, &'a mut HeaderValues);`[src]

An iterator visiting all header pairs in arbitrary order, with mutable references to the values.

`#[must_use]pub fn header_names(&self) -> Names<'_>ⓘNotable traits for Names<'a> impl<'a> Iterator for Names<'a> type Item = &'a HeaderName;`[src]

An iterator visiting all header names in arbitrary order.

`#[must_use]pub fn header_values(&self) -> Values<'_>ⓘNotable traits for Values<'a> impl<'a> Iterator for Values<'a> type Item = &'a HeaderValue;`[src]

An iterator visiting all header values in arbitrary order.

`#[must_use]pub fn content_type(&self) -> Option<Mime>`[src]

Get the response content type as a Mime.

This gets the request Content-Type header.

`pub fn set_content_type(&mut self, mime: impl Into<Mime>)`[src]

Set the response content type from a MIME.

This sets the response Content-Type header.

`pub fn set_body(&mut self, body: impl Into<Body>)`[src]

Set the body reader.

`pub fn take_body(&mut self) -> Body`[src]

Take the response body as a Body.

This method can be called after the body has already been taken or read, but will return an empty Body.

Useful for adjusting the whole body, such as in middleware.

`pub fn swap_body(&mut self, body: &mut Body)`[src]

Swaps the value of the body with another body, without deinitializing either one.

Examples

use tide::Response;

let mut req = Response::new(200);
req.set_body("Hello, Nori!");

let mut body = "Hello, Chashu!".into();
req.swap_body(&mut body);

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

`pub fn insert_cookie(&mut self, cookie: Cookie<'static>)`[src]

Insert cookie in the cookie jar.

`pub fn remove_cookie(&mut self, cookie: Cookie<'static>)`[src]

Removes the cookie. This instructs the CookiesMiddleware to send a cookie with empty value in the response.

Take care when calling this function with a cookie that was returned by Request::cookie. As per section 5.3 step 11 of RFC 6265, a new cookie is only treated as the same as an old one if it has a matching name, domain and path.

The domain and path are not sent to the server on subsequent HTTP requests, so if a cookie was originally set with a domain and/or path, calling this function on a cookie with the same name but with either a different, or no, domain and/or path will lead to us sending an empty cookie that the user agent will treat as unrelated to the original one, and will thus not remove the old one.

To avoid this you can manually set the domain and path as necessary after retrieving the cookie using Request::cookie.

`pub fn error(&self) -> Option<&Error>`[src]

Returns an optional reference to an error if the response contains one.

`pub fn downcast_error<E>(&self) -> Option<&E> where E: Display + Debug + Send + Sync + 'static,` [src]

Returns a reference to the original error associated with this response if there is one and if it can be downcast to the specified type.

Example

use tide::Response;

let error = std::io::Error::new(ErrorKind::Other, "oh no!");
let error = tide::http::Error::from(error);

let mut res = Response::new(400);
res.set_error(error);

if let Some(err) = res.downcast_error::<std::io::Error>() {
  // Do something with the `std::io::Error`.
}

`pub fn take_error(&mut self) -> Option<Error>`[src]

Takes the error from the response if one exists, replacing it with None.

`pub fn set_error(&mut self, error: impl Into<Error>)`[src]

Sets the response's error, overwriting any existing error.

This is particularly useful for middleware which would like to notify further middleware that an error has occured without overwriting the existing response.