Struct Response 

#[non_exhaustive]
pub struct Response {
    pub status_code: Option<StatusCode>,
    pub headers: HeaderMap,
    pub version: Version,
    pub cookies: CookieJar,
    pub body: ResBody,
    pub extensions: Extensions,
}

Represents an HTTP response.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

status_code: Option<StatusCode>

The HTTP status code.WebTransportSession

headers: HeaderMap

The HTTP headers.

version: Version

The HTTP version.

cookies: CookieJar

The HTTP cookies.

body: ResBody

The HTTP body.

extensions: Extensions

Used to store extra data derived from the underlying protocol.

Implementations

impl Response

pub fn new() -> Response

Creates a new blank Response.

pub fn with_cookies(cookies: CookieJar) -> Response

Creates a new blank Response.

pub fn headers(&self) -> &HeaderMap

Get headers reference.

pub fn headers_mut(&mut self) -> &mut HeaderMap

Get mutable headers reference.

pub fn set_headers(&mut self, headers: HeaderMap)

Sets headers.

pub fn add_header<N, V>( &mut self, name: N, value: V, overwrite: bool, ) -> Result<&mut Response, Error>

where N: IntoHeaderName, V: TryInto<HeaderValue>,

Modify a header for this response.

When overwrite is set to true, If the header is already present, the value will be replaced. When overwrite is set to false, The new header is always appended to the request, even if the header already exists.

pub fn version(&self) -> Version

Get version.

pub fn version_mut(&mut self) -> &mut Version

Get mutable version reference.

pub fn body_mut(&mut self) -> &mut ResBody

Get mutable body reference.

pub fn body(&mut self, body: impl Into<ResBody>) -> &mut Response

Sets body.

pub fn replace_body(&mut self, body: ResBody) -> ResBody

Sets body to a new value and returns old value.

pub fn take_body(&mut self) -> ResBody

Take body from response.

pub fn is_stamped(&mut self) -> bool

If returns true, it means this response is ready for write back and the reset handlers should be skipped.

pub fn cookies(&self) -> &CookieJar

Get cookies reference.

pub fn cookies_mut(&mut self) -> &mut CookieJar

Get mutable cookies reference.

pub fn cookie<T>(&self, name: T) -> Option<&Cookie<'static>>

where T: AsRef<str>,

Helper function for get cookie.

pub fn add_cookie(&mut self, cookie: Cookie<'static>) -> &mut Response

Helper function for add cookie.

pub fn remove_cookie(&mut self, name: &str) -> &mut Response

Helper function for remove cookie.

Removes cookie from this CookieJar. If an original cookie with the same name as cookie is present in the jar, a removal cookie will be present in the delta computation. To properly generate the removal cookie, cookie must contain the same path and domain as the cookie that was initially set.

A “removal” cookie is a cookie that has the same name as the original cookie but has an empty value, a max-age of 0, and an expiration date far in the past.

Read more about removal cookies.

pub fn content_type(&self) -> Option<Mime>

Get content type..

Example

use salvo_core::http::{Response, StatusCode};

let mut res = Response::new();
assert_eq!(None, res.content_type());
res.headers_mut().insert("content-type", "text/plain".parse().unwrap());
assert_eq!(Some(mime::TEXT_PLAIN), res.content_type());

pub fn status_code(&mut self, code: StatusCode) -> &mut Response

Sets status code and returns &mut Self.

Example

use salvo_core::http::StatusCode;
use salvo_core::http::response::Response;

let mut res = Response::new();
res.status_code(StatusCode::OK);

pub fn render<P>(&mut self, scribe: P)

where P: Scribe,

Render content.

Example

use salvo_core::http::{Response, StatusCode};

let mut res = Response::new();
res.render("hello world");

pub fn stuff<P>(&mut self, code: StatusCode, scribe: P)

where P: Scribe,

Render content with status code.

pub async fn send_file<P>(&mut self, path: P, req_headers: &HeaderMap)

where P: Into<PathBuf> + Send,

Attempts to send a file. If file not exists, not found error will occur.

If you want more settings, you can use NamedFile::builder to create a new NamedFileBuilder.

pub fn write_body(&mut self, data: impl Into<Bytes>) -> Result<(), Error>

Write bytes data to body. If body is none, a new ResBody will created.

pub fn stream<S, O, E>(&mut self, stream: S)

where S: Stream<Item = Result<O, E>> + Send + 'static, O: Into<BytesFrame> + 'static, E: Into<Box<dyn Error + Send + Sync>> + 'static,

Set response’s body to stream.

pub fn channel(&mut self) -> BodySender

Create a Body stream with an associated sender half.

Useful when wanting to stream chunks from another thread.

Example

use salvo_core::prelude::*;
#[handler]
async fn hello(res: &mut Response) {
    res.add_header("content-type", "text/plain", true).unwrap();
    let mut tx = res.channel();
    tokio::spawn(async move {
        tx.send_data("Hello world").await.unwrap();
    });
}

Trait Implementations

impl Debug for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Response

fn default() -> Response

Returns the “default value” for a type.

impl Display for Response

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<B> From<Response<B>> for Response

where B: Into<ResBody>,

fn from(res: Response<B>) -> Response

Converts to this type from the input type.

impl ResponseExt for Response

async fn take_string(&mut self) -> Result<String, Error>

Take body as String from response.

async fn take_json<T>(&mut self) -> Result<T, Error>

where T: DeserializeOwned,

Take body as deserialize it to type T instance.

async fn take_string_with_charset( &mut self, content_type: Option<&Mime>, charset: &str, compress: Option<&str>, ) -> Result<String, Error>

Take body as String from response with charset.

async fn take_bytes( &mut self, content_type: Option<&Mime>, ) -> Result<Bytes, Error>

Take all body bytes. If body is none, it will creates and returns a new Bytes.