Struct Rule 

pub struct Rule<'a, R, V, E: PartialEq + Eq + Send + Sync> { /* private fields */ }

Binds a KpType (from #[derive(Kp)]) to a root value and a list of validation predicates.

Each rule is a bool predicate plus an E value returned when the predicate is false.

Semantics

• Mandatory rules run in order. The first predicate that returns false stops the run; apply returns vec![that rule’s E].
• Non-mandatory rules run in parallel (Rayon). Each predicate that returns false contributes its E; passing rules produce no entry. The result may be empty if all pass.

Examples

use key_paths_derive::Kp;
use par_validator::builder::Rule;

#[derive(Kp)]
struct Invoice {
    reference: String,
}

fn non_blank(r: Option<&String>) -> bool {
    r.map(|s| !s.trim().is_empty()).unwrap_or(false)
}

fn len_at_most_8(r: Option<&String>) -> bool {
    r.map(|s| s.len() <= 8).unwrap_or(false)
}

let inv = Invoice {
    reference: "INV-01".into(),
};

let failures: Vec<&'static str> = Rule::new(Invoice::reference())
    .with_root(&inv)
    .mandatory_rule(non_blank, "reference_blank")
    .rule(len_at_most_8, "reference_too_long")
    .apply();

assert!(failures.is_empty());

let bad = Invoice {
    reference: "TOO_LONG_REFERENCE".into(),
};
let failures = Rule::new(Invoice::reference())
    .with_root(&bad)
    .mandatory_rule(non_blank, "reference_blank")
    .rule(len_at_most_8, "reference_too_long")
    .apply();

assert_eq!(failures, vec!["reference_too_long"]);

Implementations

impl<'a, R, V, E> Rule<'a, R, V, E>

where E: Debug + Clone + 'static + PartialEq + Eq + Send + Sync, R: Sync, V: Sync,

pub fn new(kp: KpType<'a, R, V>) -> Self

Starts a builder for the given statically dispatched key path (#[derive(Kp)] fields).

pub fn with_root(self, root: &'a R) -> Self

Supply the struct instance root that the key path reads from.

pub fn rule(self, f: fn(Option<&'a V>) -> bool, e: E) -> Self

Append a rule executed in parallel with other non-mandatory rules when you call apply.

pub fn mandatory_rule(self, f: fn(Option<&'a V>) -> bool, e: E) -> Self

Rule that runs before parallel rules, in order. On the first predicate that returns false, apply returns vec![e] for that rule’s error value e.

pub fn apply(&self) -> Vec<E>

Resolves Option<&V> via the key path, runs mandatory rules, then runs remaining rules on a Rayon thread pool.