Struct ValidatorFn

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

Function to perform validation on a form field.

Example

use form_validation::{Validation, ValidationError, ValidatorFn};

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

let key = "field1".to_string();
assert!(v.validate_value(&20, &key).is_ok());
let errors = 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> ValidatorFn<Value, Key>

pub fn new<C>(closure: C) -> Self

where C: Fn(&Value, &Key) -> Result<(), ValidationErrors<Key>> + 'static,

Create a new ValidatorFn.

Trait Implementations

impl<Value, Key> Clone for ValidatorFn<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 ValidatorFn<Value, Key>

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

Formats the value using the given formatter.

impl<C, Value, Key> From<C> for ValidatorFn<Value, Key>

where C: Fn(&Value, &Key) -> Result<(), ValidationErrors<Key>> + 'static,

fn from(closure: C) -> Self

Converts to this type from the input type.

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 ValidatorFn<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.

impl<Value, Key> Validation<Value, Key> for ValidatorFn<Value, Key>

where Key: Clone + PartialEq,

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

Validate a given form field referenced by a given Key, that contains a given Value, returns ValidationErrors if there are any.