Struct Response 

pub struct Response {
    pub status: StatusCode,
    pub headers: HeaderMap,
    pub body: Bytes,
    /* private fields */
}

Available on crate feature core and non-WebAssembly only.

HTTP Response representation

Fields

status: StatusCode

The HTTP status code.

headers: HeaderMap

The response headers.

body: Bytes

The response body as raw bytes.

Implementations

impl Response

pub fn new(status: StatusCode) -> Response

Create a new Response with the given status code

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::new(StatusCode::OK);
assert_eq!(response.status, StatusCode::OK);
assert!(response.body.is_empty());

pub fn ok() -> Response

Create a Response with HTTP 200 OK status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::ok();
assert_eq!(response.status, StatusCode::OK);

pub fn created() -> Response

Create a Response with HTTP 201 Created status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::created();
assert_eq!(response.status, StatusCode::CREATED);

pub fn no_content() -> Response

Create a Response with HTTP 204 No Content status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::no_content();
assert_eq!(response.status, StatusCode::NO_CONTENT);

pub fn bad_request() -> Response

Create a Response with HTTP 400 Bad Request status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::bad_request();
assert_eq!(response.status, StatusCode::BAD_REQUEST);

pub fn unauthorized() -> Response

Create a Response with HTTP 401 Unauthorized status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::unauthorized();
assert_eq!(response.status, StatusCode::UNAUTHORIZED);

pub fn forbidden() -> Response

Create a Response with HTTP 403 Forbidden status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::forbidden();
assert_eq!(response.status, StatusCode::FORBIDDEN);

pub fn not_found() -> Response

Create a Response with HTTP 404 Not Found status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::not_found();
assert_eq!(response.status, StatusCode::NOT_FOUND);

pub fn internal_server_error() -> Response

Create a Response with HTTP 500 Internal Server Error status

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::internal_server_error();
assert_eq!(response.status, StatusCode::INTERNAL_SERVER_ERROR);

pub fn gone() -> Response

Create a Response with HTTP 410 Gone status

Used when a resource has been permanently removed.

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::gone();
assert_eq!(response.status, StatusCode::GONE);

pub fn permanent_redirect(location: impl AsRef<str>) -> Response

Create a Response with HTTP 301 Moved Permanently (permanent redirect)

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::permanent_redirect("/new-location");
assert_eq!(response.status, StatusCode::MOVED_PERMANENTLY);
assert_eq!(
    response.headers.get("location").unwrap().to_str().unwrap(),
    "/new-location"
);

pub fn temporary_redirect(location: impl AsRef<str>) -> Response

Create a Response with HTTP 302 Found (temporary redirect)

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::temporary_redirect("/temp-location");
assert_eq!(response.status, StatusCode::FOUND);
assert_eq!(
    response.headers.get("location").unwrap().to_str().unwrap(),
    "/temp-location"
);

pub fn temporary_redirect_preserve_method(location: impl AsRef<str>) -> Response

Create a Response with HTTP 307 Temporary Redirect (preserves HTTP method)

Unlike 302, this guarantees the request method is preserved during redirect.

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::temporary_redirect_preserve_method("/temp-location");
assert_eq!(response.status, StatusCode::TEMPORARY_REDIRECT);
assert_eq!(
    response.headers.get("location").unwrap().to_str().unwrap(),
    "/temp-location"
);

pub fn with_body(self, body: impl Into<Bytes>) -> Response

Set the response body

Examples

use reinhardt_http::Response;
use bytes::Bytes;

let response = Response::ok().with_body("Hello, World!");
assert_eq!(response.body, Bytes::from("Hello, World!"));

pub fn try_with_header(self, name: &str, value: &str) -> Result<Response, Error>

Try to add a custom header to the response, returning an error on invalid inputs.

Errors

Returns Err if the header name or value is invalid according to HTTP specifications.

Examples

use reinhardt_http::Response;

let response = Response::ok().try_with_header("X-Custom-Header", "custom-value").unwrap();
assert_eq!(
    response.headers.get("X-Custom-Header").unwrap().to_str().unwrap(),
    "custom-value"
);

use reinhardt_http::Response;

// Invalid header names return an error instead of panicking
let result = Response::ok().try_with_header("Invalid Header", "value");
assert!(result.is_err());

pub fn with_header_if_absent(self, name: &str, value: &str) -> Response

Add a custom header to the response only if it is not already present.

If the header already exists, the existing value is preserved. Invalid header names or values are silently ignored. Use try_with_header_if_absent if you need error reporting.

This is useful in middleware that should not overwrite headers already set by handlers (e.g., handler-specific CSP headers should survive middleware processing).

Examples

use reinhardt_http::Response;

// Inserts the header when it is not already present
let response = Response::ok().with_header_if_absent("X-Custom", "first");
assert_eq!(
    response.headers.get("X-Custom").unwrap().to_str().unwrap(),
    "first"
);

use reinhardt_http::Response;

// Preserves the existing header value
let response = Response::ok()
    .with_header("X-Custom", "original")
    .with_header_if_absent("X-Custom", "overwrite-attempt");
assert_eq!(
    response.headers.get("X-Custom").unwrap().to_str().unwrap(),
    "original"
);

use reinhardt_http::Response;

// Invalid header names are silently ignored (no panic)
let response = Response::ok().with_header_if_absent("Invalid Header", "value");
assert!(response.headers.is_empty());

pub fn try_with_header_if_absent( self, name: &str, value: &str, ) -> Result<Response, Error>

Add a custom header to the response only if it is not already present, returning an error for invalid header names or values.

If the header already exists, the existing value is preserved and Ok(self) is returned without modification.

Errors

Returns an error if the header name or value is invalid.

Examples

use reinhardt_http::Response;

// Inserts when absent
let response = Response::ok()
    .try_with_header_if_absent("X-Custom", "value")
    .unwrap();
assert_eq!(
    response.headers.get("X-Custom").unwrap().to_str().unwrap(),
    "value"
);

use reinhardt_http::Response;

// Preserves existing header value
let response = Response::ok()
    .try_with_header("X-Custom", "original")
    .unwrap()
    .try_with_header_if_absent("X-Custom", "overwrite-attempt")
    .unwrap();
assert_eq!(
    response.headers.get("X-Custom").unwrap().to_str().unwrap(),
    "original"
);

use reinhardt_http::Response;

// Invalid header names return an error
let result = Response::ok().try_with_header_if_absent("Invalid Header", "value");
assert!(result.is_err());

pub fn with_header(self, name: &str, value: &str) -> Response

Add a custom header to the response.

Invalid header names or values are silently ignored. Use try_with_header if you need error reporting.

Examples

use reinhardt_http::Response;

let response = Response::ok().with_header("X-Custom-Header", "custom-value");
assert_eq!(
    response.headers.get("X-Custom-Header").unwrap().to_str().unwrap(),
    "custom-value"
);

use reinhardt_http::Response;

// Invalid header names are silently ignored (no panic)
let response = Response::ok().with_header("Invalid Header", "value");
assert!(response.headers.is_empty());

pub fn append_header(self, name: &str, value: &str) -> Response

Append a header value without replacing existing values.

Unlike with_header which replaces any existing value for the same header name, this method adds the value alongside existing ones. Required for headers like Set-Cookie where multiple values must coexist as separate header lines (RFC 6265 Section 4.1).

Examples

use reinhardt_http::Response;

let response = Response::ok()
    .append_header("Set-Cookie", "a=1; Path=/")
    .append_header("Set-Cookie", "b=2; Path=/");
let cookies: Vec<_> = response.headers.get_all("set-cookie").iter().collect();
assert_eq!(cookies.len(), 2);

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

Add a Location header to the response (typically used for redirects)

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

let response = Response::new(StatusCode::FOUND).with_location("/redirect-target");
assert_eq!(
    response.headers.get("location").unwrap().to_str().unwrap(),
    "/redirect-target"
);

pub fn with_json<T>(self, data: &T) -> Result<Response, Error>

where T: Serialize,

Set the response body to JSON and add appropriate Content-Type header

Examples

use reinhardt_http::Response;
use serde_json::json;

let data = json!({"message": "Hello, World!"});
let response = Response::ok().with_json(&data).unwrap();

assert_eq!(
    response.headers.get("content-type").unwrap().to_str().unwrap(),
    "application/json"
);

pub fn with_typed_header(self, key: HeaderName, value: HeaderValue) -> Response

Add a custom header using typed HeaderName and HeaderValue

Examples

use reinhardt_http::Response;
use hyper::header::{HeaderName, HeaderValue};

let header_name = HeaderName::from_static("x-custom-header");
let header_value = HeaderValue::from_static("custom-value");
let response = Response::ok().with_typed_header(header_name, header_value);

assert_eq!(
    response.headers.get("x-custom-header").unwrap().to_str().unwrap(),
    "custom-value"
);

pub fn should_stop_chain(&self) -> bool

Check if this response should stop the middleware chain

When true, no further middleware or handlers will be executed.

Examples

use reinhardt_http::Response;

let response = Response::ok();
assert!(!response.should_stop_chain());

let stopping_response = Response::ok().with_stop_chain(true);
assert!(stopping_response.should_stop_chain());

pub fn with_stop_chain(self, stop: bool) -> Response

Set whether this response should stop the middleware chain

When set to true, the middleware chain will stop processing and return this response immediately, skipping any remaining middleware and handlers.

This is useful for early returns in middleware, such as:

• Authentication failures (401 Unauthorized)
• CORS preflight responses (204 No Content)
• Rate limiting rejections (429 Too Many Requests)
• Cache hits (304 Not Modified)

Examples

use reinhardt_http::Response;
use hyper::StatusCode;

// Early return for authentication failure
let auth_failure = Response::unauthorized()
    .with_body("Authentication required")
    .with_stop_chain(true);
assert!(auth_failure.should_stop_chain());

// CORS preflight response
let preflight = Response::no_content()
    .with_header("Access-Control-Allow-Origin", "*")
    .with_stop_chain(true);
assert!(preflight.should_stop_chain());

Trait Implementations

impl Clone for Response

fn clone(&self) -> Response

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Response

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

Formats the value using the given formatter.

impl From<Error> for Response

fn from(error: Error) -> Response

Converts to this type from the input type.

impl From<GetError> for Response

fn from(error: GetError) -> Response

Converts to this type from the input type.

impl IntoResponse for Response

fn into_response(self) -> Response

Convert self into an HTTP response

impl PartialEq for Response

fn eq(&self, other: &Response) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Response

impl StructuralPartialEq for Response