Struct actix_form_data::Form

pub struct Form { /* fields omitted */ }

A structure that defines the fields expected in form data

Example

let form = Form::new()
    .field("field-name", Field::text())
    .field("second-field", Field::int())
    .field("third-field", Field::float())
    .field("fifth-field", Field::file(|_, _, _| async move {
        Ok(None) as Result<_, std::convert::Infallible>
    }))
    .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 Form

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

Add an optional error handler to transform errors produced by the middleware

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) -> Self

Trait Implementations

impl Clone for Form

fn clone(&self) -> Form

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Form

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

Formats the value using the given formatter.

impl<S> Transform<S, ServiceRequest> for Form where
    S: Service<ServiceRequest, Error = Error>,
    S::Future: 'static, 

type Response = S::Response

Responses produced by the service.

type Error = S::Error

Errors produced by the service.

type InitError = ()

Errors produced while building a transform service.

type Transform = MultipartMiddleware<S>

The TransformService value created by this factory

type Future = Ready<Result<Self::Transform, Self::InitError>>

The future response value.

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

Creates and returns a new Transform component, asynchronously