Struct form_validation::AsyncValidatorFn

pub struct AsyncValidatorFn<Value, Key> { /* fields omitted */ }

This is supported on feature="async" only.

An function to perform validation on a field asynchonously.

For the synchronous version, see ValidatorFn.

Example

use form_validation::{AsyncValidatorFn, ValidationError};
use futures::executor::block_on;

let v: AsyncValidatorFn<i32, String> =
    AsyncValidatorFn::new(|value: &i32, key: &String| {
        let key = key.clone();
        let value = *value;
        Box::pin(async move {
            // perform actions here that require async
            if value < 0 {
                Err(ValidationError::new(key.clone(), "NOT_LESS_THAN_0")
                    .with_message(move |key| {
                        format!(
                            "The value of {} ({}) cannot be less than 0",
                            key, value
                        )
                    })
                    .into()) // convert into ValidationErrors
            } else {
                Ok(())
            }
        })
    });

let key = "field1".to_string();
assert!(block_on(v.validate_value(&20, &key)).is_ok());

let errors = block_on(v.validate_value(&-1, &key)).unwrap_err();
assert_eq!(1, errors.len());
let error = errors.errors.get(0).unwrap();
assert_eq!(
    "The value of field1 (-1) cannot be less than 0",
    error.to_string()
);
assert_eq!("NOT_LESS_THAN_0", error.type_id);

Implementations

impl<Value, Key> AsyncValidatorFn<Value, Key> where
    Key: Clone + PartialEq,
    Value: Clone + PartialEq, 

pub fn new<C>(closure: C) -> Self where
    C: Fn(&Value, &Key) -> Pin<Box<dyn Future<Output = Result<(), ValidationErrors<Key>>>>> + 'static, 

Takes a closure that produces a Future that produces a ValidatorFn closure.

pub async fn validate_value<'_, '_, '_>(
    &'_ self,
    value: &'_ Value,
    key: &'_ Key
) -> Result<(), ValidationErrors<Key>>

Runs the future to produce the ValidatorFn closure, and then performs the validation with that.

Trait Implementations

impl<Value, Key> Clone for AsyncValidatorFn<Value, Key>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Value, Key> Debug for AsyncValidatorFn<Value, Key>

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

Formats the value using the given formatter.

impl<Value, Key> From<ValidatorFn<Value, Key>> for AsyncValidatorFn<Value, Key> where
    Key: Clone + PartialEq + 'static,
    Value: Clone + PartialEq + 'static, 

fn from(validator_fn: ValidatorFn<Value, Key>) -> Self

Performs the conversion.

impl<Value, Key> PartialEq<AsyncValidatorFn<Value, Key>> for AsyncValidatorFn<Value, Key>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.