Enum actix_form_data::Field

pub enum Field {
    Array(Array),
    Map(Map),
    File(Arc<dyn Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error>>>>) -> Pin<Box<dyn Future<Output = Result<Option<PathBuf>, Error>>>> + 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)

Tuple Fields of Array

0: Array

Map(Map)

Tuple Fields of Map

0: Map

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

Tuple Fields of File

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

Bytes

Int

Float

Text

Implementations

impl Field

pub fn file<F, Fut, E>(f: F) -> Self where
    F: Fn(String, Mime, Pin<Box<dyn Stream<Item = Result<Bytes, Error>>>>) -> Fut + Send + Sync + Clone + 'static,
    Fut: Future<Output = Result<Option<PathBuf>, E>> + 'static,
    E: Into<Error> + '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(None) as Result<_, std::convert::Infallible>
    }
}));

pub fn bytes() -> Self

Add a Bytes field to a form

Example

let form = Form::new().field("text-field", Field::bytes());

pub fn text() -> Self

Add a Text field to a form

Example

let form = Form::new().field("text-field", Field::text());

pub fn int() -> Self

Add an Int field to a form

Example

let form = Form::new().field("int-field", Field::int());

pub fn float() -> Self

Add a Float field to a form

Example

let form = Form::new().field("float-field", Field::float());

pub fn array(field: Field) -> Self

Add an Array to a form

Example

let form = Form::new()
    .field(
        "array-field",
        Field::array(Field::text())
    );

pub fn map() -> Map

Add a Map to a form

Example

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

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Field

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

Formats the value using the given formatter.