Struct ValidationError 

pub struct ValidationError {
    pub field: String,
    pub message: String,
}

Error type for validation failures

Fields

field: String

message: String

Implementations

impl ValidationError

pub fn new(field: impl Into<String>, message: impl Into<String>) -> Self

Examples found in repository

examples/error_handling.rs (line 23)

    fn validate(&self) -> Result<(), Vec<ValidationError>> {
        let mut errors = Vec::new();

        // Validate email
        if !is_valid_email(&self.email) {
            errors.push(ValidationError::new("email", "Invalid email format"));
        }

        // Validate phone
        if !is_valid_phone(&self.phone) {
            errors.push(ValidationError::new("phone", "Invalid phone number"));
        }

        // Validate website
        if !is_valid_https_url(&self.website) {
            errors.push(ValidationError::new("website", "Must be a valid HTTPS URL"));
        }

        // Validate credit card
        if !credit_card::is_valid_credit_card(&self.credit_card) {
            errors.push(ValidationError::new("credit_card", "Invalid credit card number"));
        }

        if errors.is_empty() {
            Ok(())
        } else {
            Err(errors)
        }
    }
}

/// Validates a password with multiple rules
fn validate_password(password: &str) -> Result<(), Vec<String>> {
    let mut errors = Vec::new();

    if !string::has_min_length(password, 8) {
        errors.push("Password must be at least 8 characters long".to_string());
    }

    if !string::has_max_length(password, 128) {
        errors.push("Password must not exceed 128 characters".to_string());
    }

    if !password.chars().any(|c| c.is_uppercase()) {
        errors.push("Password must contain at least one uppercase letter".to_string());
    }

    if !password.chars().any(|c| c.is_lowercase()) {
        errors.push("Password must contain at least one lowercase letter".to_string());
    }

    if !password.chars().any(|c| c.is_ascii_digit()) {
        errors.push("Password must contain at least one digit".to_string());
    }

    if !password.chars().any(|c| !c.is_alphanumeric()) {
        errors.push("Password must contain at least one special character".to_string());
    }

    if errors.is_empty() {
        Ok(())
    } else {
        Err(errors)
    }
}

/// Validates age with range checking
fn validate_age(age: i32) -> ValidationResult {
    if !numeric::is_in_range(age, 18, 120) {
        return Err(ValidationError::new("age", "Age must be between 18 and 120"));
    }
    Ok(())
}

Trait Implementations

impl Clone for ValidationError

fn clone(&self) -> ValidationError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationError

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

Formats the value using the given formatter.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Eq for ValidationError

impl Error for ValidationError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for ValidationError

fn eq(&self, other: &ValidationError) -> 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 StructuralPartialEq for ValidationError