Struct uiuifree_actix_web_util::web::ReqData

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

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()
}

Implementations

impl<T> ReqData<T> where
    T: 'static + Clone, 

pub fn into_inner(self) -> T

Consumes the ReqData, returning its wrapped data.

Trait Implementations

impl<T> Clone for ReqData<T> where
    T: 'static + Clone, 

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: 'static + Debug + Clone, 

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

Formats the value using the given formatter.

impl<T> Deref for ReqData<T> where
    T: 'static + Clone, 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> FromRequest for ReqData<T> where
    T: 'static + Clone, 

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<Pin<Box<dyn Stream<Item = Result<Bytes, PayloadError>> + 'static, Global>>>
) -> <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.