Enum actix_form_data::Field

pub enum Field<T, E> {
    Array(Array<T, E>),
    Map(Map<T, E>),
    File(Arc<dyn Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error<E>>>>>) -> Pin<Box<dyn Future<Output = Result<T, Error<E>>>>> + Send + Sync>),
    Bytes,
    Int,
    Float,
    Text,
}

The field type represents a field in the form-data that is allowed to be parsed.

Variants

Array(Array<T, E>)

Tuple Fields of Array

0: Array<T, E>

Map(Map<T, E>)

Tuple Fields of Map

0: Map<T, E>

File(Arc<dyn Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error<E>>>>>) -> Pin<Box<dyn Future<Output = Result<T, Error<E>>>>> + Send + Sync>)

Tuple Fields of File

0: Arc<dyn Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error<E>>>>>) -> Pin<Box<dyn Future<Output = Result<T, Error<E>>>>> + Send + Sync>

Bytes

Int

Float

Text

Implementations

impl<T, E> Field<T, E>

pub fn file<F, Fut>(f: F) -> Self where
    F: Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error<E>>>>>) -> Fut + Send + Sync + Clone + 'static,
    Fut: Future<Output = Result<T, E>> + 'static,
    E: 'static, 

Add a File field with a name generator.

The name generator will be called for each file matching this field’s key. Keep in mind that each key/file pair will have it’s own name-generator, so sharing a name-generator between fields is up to the user.

Example

let (tx, rx) = channel(1);
let form = Form::new().field("file-field", Field::file(move |_, _, mut stream| {
    let mut tx = tx.clone();
    async move {
        while let Some(res) = stream.next().await {
            if let Ok(bytes) = res {
                if let Err(_) = tx.send(bytes).await {
                    break;
                }
            }
        }
        Ok(()) as Result<_, std::io::Error>
    }
}));

pub fn bytes() -> Self

Add a Bytes field to a form

Example

let form = Form::<(), std::io::Error>::new().field("text-field", Field::bytes());

pub fn text() -> Self

Add a Text field to a form

Example

let form = Form::<(), std::io::Error>::new().field("text-field", Field::text());

pub fn int() -> Self

Add an Int field to a form

Example

let form = Form::<(), std::io::Error>::new().field("int-field", Field::int());

pub fn float() -> Self

Add a Float field to a form

Example

let form = Form::<(), std::io::Error>::new().field("float-field", Field::float());

pub fn array(field: Field<T, E>) -> Self

Add an Array to a form

Example

let form = Form::<(), std::io::Error>::new()
    .field(
        "array-field",
        Field::array(Field::text())
    );

pub fn map() -> Map<T, E>

Add a Map to a form

Example

let form = Form::<(), std::io::Error>::new()
    .field(
        "map-field",
        Field::map()
            .field("sub-field", Field::text())
            .field("sub-field-two", Field::text())
            .finalize()
    );

Trait Implementations

impl<T, E> Clone for Field<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 Field<T, E>

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

Formats the value using the given formatter.