Struct form_validation::ValidatorFn

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

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()).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());
assert!(v.validate_value(&-1, &key).is_err());
assert_eq!(
    "The value of field1 (-1) cannot be less than 0",
    v.validate_value(&-1, &key).unwrap_err().to_string()
);

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

Performs the conversion.

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<ValidatorFn<Value, Key>> for ValidatorFn<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 !=.

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.