Struct actix_form_data::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 copy 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::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, T, E>

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