Struct radish::Extension

pub struct Extension<T>(pub T);

Extractor that gets a value from request extensions.

This is commonly used to share state across handlers.

Example

use axum::{
    extract::Extension,
    routing::get,
    Router,
};
use std::sync::Arc;

// Some shared state used throughout our application
struct State {
    // ...
}

async fn handler(state: Extension<Arc<State>>) {
    // ...
}

let state = Arc::new(State { /* ... */ });

let app = Router::new().route("/", get(handler))
    // Add middleware that inserts the state into all incoming request's
    // extensions.
    .layer(Extension(state));

If the extension is missing it will reject the request with a 500 Internal Server Error response.

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Extension<T> where
    T: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Extension<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Deref for Extension<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, B> FromRequest<B> for Extension<T> where
    T: 'static + Clone + Send + Sync,
    B: Send, 

type Rejection = ExtensionRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>(
    req: &'life0 mut RequestParts<B>
) -> Pin<Box<dyn Future<Output = Result<Extension<T>, <Extension<T> as FromRequest<B>>::Rejection>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Extension<T>: 'async_trait, 

Perform the extraction.

impl<S, T> Layer<S> for Extension<T> where
    T: 'static + Clone + Send + Sync, 

type Service = AddExtension<S, T>

The wrapped service

fn layer(&self, inner: S) -> <Extension<T> as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.

impl<T> Copy for Extension<T> where
    T: Copy,