Struct ReqData

pub struct ReqData<T>(T)
where
    T: Clone + 'static;

Request-local data extractor.

Request-local data is arbitrary data attached to an individual request, usually by middleware. It can be set via extensions_mut on HttpRequest or ServiceRequest.

Unlike app data, request data is dropped when the request has finished processing. This makes it useful as a kind of messaging system between middleware and request handlers. It uses the same types-as-keys storage system as app data.

Mutating Request Data

Note that since extractors must output owned data, only types that impl Clone can use this extractor. A clone is taken of the required request data and can, therefore, not be directly mutated in-place. To mutate request data, continue to use HttpRequest::extensions_mut or re-insert the cloned data back into the extensions map. A DerefMut impl is intentionally not provided to make this potential foot-gun more obvious.

Examples

#[derive(Debug, Clone, PartialEq)]
struct FlagFromMiddleware(String);

/// Use the `ReqData<T>` extractor to access request data in a handler.
async fn handler(
    req: HttpRequest,
    opt_flag: Option<web::ReqData<FlagFromMiddleware>>,
) -> impl Responder {
    // use an option extractor if middleware is not guaranteed to add this type of req data
    if let Some(flag) = opt_flag {
        assert_eq!(&flag.into_inner(), req.extensions().get::<FlagFromMiddleware>().unwrap());
    }

    HttpResponse::Ok()
}

Tuple Fields

0: T

Implementations

impl<T> ReqData<T>

where T: Clone + 'static,

pub fn into_inner(self) -> T

Consumes the ReqData, returning its wrapped data.

Trait Implementations

impl<T> Clone for ReqData<T>

where T: Clone + 'static,

fn clone(&self) -> ReqData<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ReqData<T>

where T: Debug + Clone + 'static,

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

Formats the value using the given formatter.

impl<T> Deref for ReqData<T>

where T: Clone + 'static,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> FromRequest for ReqData<T>

where T: Clone + 'static,

type Error = Error

The associated error which can be returned.

type Future = Ready<Result<ReqData<T>, Error>>

Future that resolves to a Self.

fn from_request( req: &HttpRequest, _: &mut Payload, ) -> <ReqData<T> as FromRequest>::Future

Create a Self from request parts asynchronously.

fn extract(req: &HttpRequest) -> Self::Future

Create a Self from request head asynchronously.