Struct AsyncValidatorFn

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

Available on crate 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

Converts to this type from the input type.

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

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.