Struct Form 

pub struct Form<T, E> { /* private fields */ }

A structure that defines the fields expected in form data

Example

let form = Form::<(), Error>::new()
    .field("field-name", Field::text())
    .field("second-field", Field::int())
    .field("third-field", Field::float())
    .field("fifth-field", Field::file(|_, _, _| async move {
        Ok(())
    }))
    .field(
        "map-field",
        Field::map()
            .field("sub-field", Field::text())
            .field("sub-field-two", Field::text())
            .finalize()
    )
    .field(
        "array-field",
        Field::array(Field::text())
    );

Implementations

impl<T, E> Form<T, E>

pub fn new() -> Self

Create a new form

If you wish to provide your own executor, use the with_executor method.

Default values are as follows

• max_fields: 100
• max_field_size: 10_000 bytes
• max_files: 20
• max_files_size: 10_000_000 bytes

pub fn transform_error( self, f: impl Fn(Error) -> Error + Send + Sync + 'static, ) -> Self

Set the Transform Error method to convert Error types into actix_web::Error by hand

pub fn max_fields(self, max: u32) -> Self

Set the maximum number of fields allowed in the upload

The upload will error if too many fields are provided.

pub fn max_field_size(self, max: usize) -> Self

Set the maximum size of a field (in bytes)

The upload will error if a provided field is too large.

pub fn max_files(self, max: u32) -> Self

Set the maximum number of files allowed in the upload

THe upload will error if too many files are provided.

pub fn max_file_size(self, max: usize) -> Self

Set the maximum size for files (in bytes)

The upload will error if a provided file is too large.

pub fn field(self, name: &str, field: Field<T, E>) -> Self

Trait Implementations

impl<T, E> Clone for Form<T, E>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, E> Debug for Form<T, E>

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

Formats the value using the given formatter.

impl<T, E> Default for Form<T, E>

fn default() -> Self

Returns the “default value” for a type.

impl<S, T, E> Transform<S, ServiceRequest> for Form<T, E>

where S: Service<ServiceRequest, Error = Error>, S::Future: 'static, T: 'static, E: ResponseError + 'static,

type Response = <S as Service<ServiceRequest>>::Response

Responses produced by the service.

type Error = <S as Service<ServiceRequest>>::Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = MultipartMiddleware<S, T, E>

The TransformService value created by this factory

type Future = Ready<Result<<Form<T, E> as Transform<S, ServiceRequest>>::Transform, <Form<T, E> as Transform<S, ServiceRequest>>::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously