Struct hypers::prelude::Response

pub struct Response {
    pub cookies: CookieJar,
    /* private fields */
}

Fields

cookies: CookieJar

Implementations

impl Response

pub fn new(body: impl Into<Bytes>) -> Response

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

Add cookie

pub fn cookies(&self) -> &CookieJar

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

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

Removes cookie from this CookieJar. Read more about removal cookies.

pub fn header<K, V>(&mut self, name: K, value: V) -> &mut Response

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

Appends a header to this response . This function will append the provided key/value as a header to the internal HeaderMap being constructed. Essentially this is equivalent to calling HeaderMap::append.

Examples

let response = Response::default()
    .header("Content-Type", "text/html")
    .header("X-Custom-Foo", "bar")
    .header("content-length", 0)
    .body("");

pub fn header_typed<H>(&mut self, h: H) -> &mut Response

where H: Header,

Inserts a typed header to this response.

pub fn status<T>(&mut self, status: T) -> &mut Response

where T: TryInto<StatusCode>,

Sets the HTTP status for this response. By default this is StatusCode::OK.

pub fn redirect<T>(&mut self, status: T, url: &str) -> &mut Response

where T: TryInto<StatusCode>,

The response redirects to the specified URL. [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/Response/redirect

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

The [Content-Location][mdn] header indicates an alternate location for the returned data. [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Location

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

Write bytes data to body

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

The response with the specified [Content-Type][mdn]. [mdn]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type

pub fn content_type_str(&self) -> Result<&str, Box<dyn Error + Sync + Send>>

Get content type. return Result<&str, Error>

pub fn json<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/json; charset=utf-8 media type.

pub fn json_pretty<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/json; charset=utf-8 media type.

pub fn form<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/x-www-form-urlencoded; charset=utf-8 media type.

pub fn yaml<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/yaml; charset=utf-8 media type.

pub fn toml<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/toml; charset=utf-8 media type.

pub fn xml<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/xml; charset=utf-8 media type.

pub fn msgpack<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/msgpack; charset=utf-8 media type.

pub fn cbor<T>(&mut self, value: &T) -> &mut Response

where T: Serialize,

The response with application/cbor; charset=utf-8 media type.

pub fn render<R>(self, responder: R) -> Response

where R: Responder,

Render content.

Example

use hypers_core::prelude::Response;

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

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

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

Responds to a stream.

pub async fn file<P>( &mut self, file_path: P, req_headers: &HeaderMap, ) -> &mut Response

where P: Into<PathBuf> + Send,

file writes the specified file into the body stream in an efficient way. If file not exists, not found error will occur.

pub fn download(&mut self, file_path: impl AsRef<Path>) -> &mut Response

download writes the specified file into the body stream in an efficient way. On the client side, the file will typically be downloaded with the given filename.

pub fn take_body(&mut self) -> Body

Take body form the request

pub async fn payload(&mut self) -> Result<Bytes, Box<dyn Error + Sync + Send>>

Get Bytes from response payload

pub fn into_hyper(self) -> Result<Response<Body>, InvalidHeaderValue>

Convert to hyper response.

pub fn map<F>(self, f: F) -> Response

where F: FnOnce(Body) -> Body,

impl Response

pub fn assert_status<T>(&mut self, status: T)

where T: TryInto<StatusCode>,

Asserts that the status code is equals to status.

pub fn assert_status_is_ok(&mut self)

Asserts that the status code is 200 OK.

pub fn assert_header<K, V>(&self, key: K, value: V)

where K: TryInto<HeaderName>, V: TryInto<HeaderValue>,

Asserts that header key is equals to value.

pub fn assert_content_type(&self, content_type: &str)

Asserts that content type is equals to content_type.

pub async fn assert_body(&mut self, bytes: impl Into<Bytes>)

Asserts that the response body is bytes::Bytes and it equals to bytes::Bytes.

pub async fn assert_json(&mut self, json: &impl Serialize)

Asserts that the response body is JSON and it equals to json.

pub async fn assert_xml(&mut self, xml: &impl Serialize)

Asserts that the response body is XML and it equals to xml.

pub async fn assert_yaml(&mut self, yaml: &impl Serialize)

Asserts that the response body is yaml and it equals to yaml.

pub async fn take_string( &mut self, ) -> Result<String, Box<dyn Error + Sync + Send>>

pub async fn take_json<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_form<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_yaml<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_toml<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_xml<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_msgpack<T>( &mut self, ) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

pub async fn take_cbor<T>(&mut self) -> Result<T, Box<dyn Error + Sync + Send>>

where T: DeserializeOwned,

Methods from Deref<Target = Response<Body>>

pub fn status(&self) -> StatusCode

Returns the StatusCode.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.status(), StatusCode::OK);

pub fn status_mut(&mut self) -> &mut StatusCode

Returns a mutable reference to the associated StatusCode.

Examples

let mut response: Response<()> = Response::default();
*response.status_mut() = StatusCode::CREATED;
assert_eq!(response.status(), StatusCode::CREATED);

pub fn version(&self) -> Version

Returns a reference to the associated version.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.version(), Version::HTTP_11);

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

Returns a mutable reference to the associated version.

Examples

let mut response: Response<()> = Response::default();
*response.version_mut() = Version::HTTP_2;
assert_eq!(response.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

Examples

let response: Response<()> = Response::default();
assert!(response.headers().is_empty());

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

Returns a mutable reference to the associated header field map.

Examples

let mut response: Response<()> = Response::default();
response.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!response.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let response: Response<()> = Response::default();
assert!(response.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut response: Response<()> = Response::default();
response.extensions_mut().insert("hello");
assert_eq!(response.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let response: Response<String> = Response::default();
assert!(response.body().is_empty());

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

Returns a mutable reference to the associated HTTP body.

Examples

let mut response: Response<String> = Response::default();
response.body_mut().push_str("hello world");
assert!(!response.body().is_empty());

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 Deref for Response

type Target = Response<Body>

The resulting type after dereferencing.

fn deref(&self) -> &<Response as Deref>::Target

Dereferences the value.

impl DerefMut for Response

fn deref_mut(&mut self) -> &mut <Response as Deref>::Target

Mutably dereferences the value.

impl HandlerOut for Response

fn register(_: &mut Components, _: &mut Operation)

Modify the OpenApi components section or current operation information with given argument. This function is called by macros internal.

impl Responder for Response

fn response(self, _: Response) -> Response

impl SessionDepotExt for Response

fn set_session(&mut self, session: Session) -> &mut Response

Sets session

fn take_session(&mut self) -> Option<Session>

Take session

fn session(&self) -> Option<&Session>

Get session reference

fn session_mut(&mut self) -> Option<&mut Session>

Get session mutable reference