Struct actix_web_lab::extract::Json

pub struct Json<T, const LIMIT: usize = DEFAULT_JSON_LIMIT>(pub T);

JSON extractor with const-generic payload size limit.

Json is used to extract typed data from JSON request payloads.

Extractor

To extract typed data from a request body, the inner type T must implement the serde::Deserialize trait.

Use the LIMIT const generic parameter to control the payload size limit. The default limit that is exported (DEFAULT_LIMIT) is 2MiB.

use actix_web::{post, App};
use actix_web_lab::extract::{DEFAULT_JSON_LIMIT, Json};
use serde::Deserialize;

#[derive(Deserialize)]
struct Info {
    username: String,
}

/// Deserialize `Info` from request's body.
#[post("/")]
async fn index(info: Json<Info>) -> String {
    format!("Welcome {}!", info.username)
}

const LIMIT_32_MB: usize = 33_554_432;

/// Deserialize payload with a higher 32MiB limit.
#[post("/big-payload")]
async fn big_payload(info: Json<Info, LIMIT_32_MB>) -> String {
    format!("Welcome {}!", info.username)
}

Tuple Fields

0: T

Implementations

impl<T, const LIMIT: usize> Json<T, LIMIT>

pub fn into_inner(self) -> T

Unwraps into inner T value.

Trait Implementations

impl<T: Debug, const LIMIT: usize> Debug for Json<T, LIMIT>

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

Formats the value using the given formatter.

impl<T, const LIMIT: usize> Deref for Json<T, LIMIT>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const LIMIT: usize> DerefMut for Json<T, LIMIT>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, const LIMIT: usize> Display for Json<T, LIMIT>where T: Display,

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

Formats the value using the given formatter.

impl<T: DeserializeOwned, const LIMIT: usize> FromRequest for Json<T, LIMIT>

See here for example of usage as an extractor.

type Error = Error

The associated error which can be returned.

type Future = JsonExtractFut<T, LIMIT>

Future that resolves to a Self.

fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future

Create a Self from request parts asynchronously.

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

Create a Self from request head asynchronously.