Struct AsyncValidator

pub struct AsyncValidator<Value, Key> {
    pub validations: Vec<AsyncValidatorFn<Value, Key>>,
}

Available on crate feature async only.

Validates a particular type of value asynchronously, can contain many validation functions. Generally used with a single key for all contained validation functions.

See Validator for the synchronous version.

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

let v: AsyncValidator<i32, String> = AsyncValidator::new()
    .validation(AsyncValidatorFn::new(|value: &i32, key: &String| {
        let value = *value;
        let key = key.clone();
        Box::pin(async move {
            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(())
            }
        })
    }))
    // also supports compatibility with the synchronous ValidatorFn
    .validation(ValidatorFn::new(|value: &i32, key: &String| {
        if value > &10 {
            let value_clone = *value;
            Err(ValidationError::new(key.clone(), "NOT_GREATER_THAN_10")
                .with_message(move |key| {
                    format!(
                        "The value of {} ({}) cannot be greater than 10",
                        key, value_clone
                    )
                })
                .into()) // convert into ValidationErrors
        } else {
            Ok(())
        }
    }));
let key = "field1".to_string();
{
    let errors = block_on(v.validate_value(&11, &key)).unwrap_err();
    assert_eq!(1, errors.len());
    let error = errors.errors.get(0).unwrap();
    assert_eq!("NOT_GREATER_THAN_10", error.type_id);
}

assert!(block_on(v.validate_value(&5, &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!("NOT_LESS_THAN_0", error.type_id);
}

Fields

validations: Vec<AsyncValidatorFn<Value, Key>>

Implementations

impl<Value, Key> AsyncValidator<Value, Key>

where Key: Clone + PartialEq, Value: Clone + PartialEq,

pub fn new() -> Self

Create a new Validator.

pub fn validation<F: Into<AsyncValidatorFn<Value, Key>> + 'static>( self, async_validator_fn: F, ) -> Self

A factory method to add a validation function to this validator.

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

Trait Implementations

impl<Value: Clone, Key: Clone> Clone for AsyncValidator<Value, Key>

fn clone(&self) -> AsyncValidator<Value, Key>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Value: Debug, Key: Debug> Debug for AsyncValidator<Value, Key>

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

Formats the value using the given formatter.

impl<Value, Key> Default for AsyncValidator<Value, Key>

where Key: Clone + PartialEq, Value: Clone + PartialEq,

fn default() -> Self

Returns the “default value” for a type.

impl<Value, Key> From<Validator<Value, Key>> for AsyncValidator<Value, Key>

where Value: Clone + PartialEq + 'static, Key: Clone + PartialEq + 'static,

fn from(validator: Validator<Value, Key>) -> Self

Converts to this type from the input type.

impl<Value: PartialEq, Key: PartialEq> PartialEq for AsyncValidator<Value, Key>

fn eq(&self, other: &AsyncValidator<Value, Key>) -> 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.

impl<Value, Key> StructuralPartialEq for AsyncValidator<Value, Key>