pub trait IntoResponseParts {
type Error: IntoResponse;
// Required method
fn into_response_parts(
self,
res: ResponseParts,
) -> Result<ResponseParts, Self::Error>;
}Expand description
Trait for adding headers and extensions to a response.
§Example
use axum::{
response::{ResponseParts, IntoResponse, IntoResponseParts, Response},
http::{StatusCode, header::{HeaderName, HeaderValue}},
};
// Hypothetical helper type for setting a single header
struct SetHeader<'a>(&'a str, &'a str);
impl<'a> IntoResponseParts for SetHeader<'a> {
type Error = (StatusCode, String);
fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> {
match (self.0.parse::<HeaderName>(), self.1.parse::<HeaderValue>()) {
(Ok(name), Ok(value)) => {
res.headers_mut().insert(name, value);
},
(Err(_), _) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Invalid header name {}", self.0),
));
},
(_, Err(_)) => {
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
format!("Invalid header value {}", self.1),
));
},
}
Ok(res)
}
}
// It's also recommended to implement `IntoResponse` so `SetHeader` can be used on its own as
// the response
impl<'a> IntoResponse for SetHeader<'a> {
fn into_response(self) -> Response {
// This gives an empty response with the header
(self, ()).into_response()
}
}
// We can now return `SetHeader` in responses
//
// Note that returning `impl IntoResponse` might be easier if the response has many parts to
// it. The return type is written out here for clarity.
async fn handler() -> (SetHeader<'static>, SetHeader<'static>, &'static str) {
(
SetHeader("server", "axum"),
SetHeader("x-foo", "custom"),
"body",
)
}
// Or on its own as the whole response
async fn other_handler() -> SetHeader<'static> {
SetHeader("x-foo", "custom")
}Required Associated Types§
Sourcetype Error: IntoResponse
type Error: IntoResponse
The type returned in the event of an error.
This can be used to fallibly convert types into headers or extensions.
Required Methods§
Sourcefn into_response_parts(
self,
res: ResponseParts,
) -> Result<ResponseParts, Self::Error>
fn into_response_parts( self, res: ResponseParts, ) -> Result<ResponseParts, Self::Error>
Set parts of the response
Dyn Compatibility§
This trait is dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".