Struct actix_web_lab::extract::BodyLimit

pub struct BodyLimit<T, const LIMIT: usize = DEFAULT_BODY_LIMIT> { /* private fields */ }

Extractor wrapper that limits size of payload used.

Examples

use actix_web::{get, web::Bytes, Responder};
use actix_web_lab::extract::BodyLimit;

const BODY_LIMIT: usize = 1_048_576; // 1MB

#[get("/")]
async fn handler(body: BodyLimit<Bytes, BODY_LIMIT>) -> impl Responder {
    let body = body.into_inner();
    assert!(body.len() < BODY_LIMIT);
    body
}

Implementations

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

pub fn into_inner(self) -> T

Returns inner extracted type.

Trait Implementations

impl<T, const LIMIT: usize> AsRef<T> for BodyLimit<T, LIMIT>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Formats the value using the given formatter.

impl<T: Display, const LIMIT: usize> Display for BodyLimit<T, LIMIT>

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

Formats the value using the given formatter.

impl<T, const LIMIT: usize> From<T> for BodyLimit<T, LIMIT>

fn from(inner: T) -> Self

Converts to this type from the input type.

impl<T, const LIMIT: usize> FromRequest for BodyLimit<T, LIMIT>

where T: FromRequest + 'static, T::Error: Debug + Display,

type Error = BodyLimitError<T>

The associated error which can be returned.

type Future = BodyLimitFut<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.

impl<T: PartialEq, const LIMIT: usize> PartialEq for BodyLimit<T, LIMIT>

fn eq(&self, other: &BodyLimit<T, LIMIT>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq, const LIMIT: usize> Eq for BodyLimit<T, LIMIT>

impl<T, const LIMIT: usize> StructuralPartialEq for BodyLimit<T, LIMIT>