Struct ValidationError 

pub struct ValidationError { /* private fields */ }

A lightweight validation failure with a machine-readable code and a human-readable message.

ValidationError is the default error returned by the simple validators in this crate and the recommended starting point for hand-written ones. It is Copy, holds no owned data, and never allocates, which keeps it usable on a hot path and in no_std builds alike.

The code is meant to be a stable, lowercase identifier you can match on ("non_empty", "out_of_range"); the message is meant for logs and end-user diagnostics. Keep the code stable across releases even if you reword the message.

Under the std feature it implements std::error::Error, so it slots into ? and Box<dyn Error> chains without ceremony.

Examples

Construct one directly and inspect its parts:

use type_lib::ValidationError;

let err = ValidationError::new("non_empty", "value must not be empty");
assert_eq!(err.code(), "non_empty");
assert_eq!(err.message(), "value must not be empty");

Branch on the stable code while showing the message to a human:

use type_lib::ValidationError;

fn describe(err: &ValidationError) -> &'static str {
    match err.code() {
        "non_empty" => "the field was left blank",
        "out_of_range" => "the number is outside the allowed range",
        _ => "the value is invalid",
    }
}

let err = ValidationError::new("out_of_range", "expected 1..=10, got 42");
assert_eq!(describe(&err), "the number is outside the allowed range");

Format it for display (the Display output is "<code>: <message>"):

use type_lib::ValidationError;

let err = ValidationError::new("non_empty", "value must not be empty");
assert_eq!(err.to_string(), "non_empty: value must not be empty");

Implementations

impl ValidationError

pub const fn new(code: &'static str, message: &'static str) -> Self

Creates a validation error from a stable code and a human-readable message.

This is a const fn, so errors can be declared as associated constants or statics and reused without per-call construction cost.

Examples

use type_lib::ValidationError;

const EMPTY: ValidationError =
    ValidationError::new("non_empty", "value must not be empty");
assert_eq!(EMPTY.code(), "non_empty");

pub const fn code(&self) -> &'static str

Returns the stable, machine-readable error code.

Use this to branch programmatically; it is intended to stay stable across releases even when the message changes.

Examples

use type_lib::ValidationError;

let err = ValidationError::new("non_empty", "value must not be empty");
assert_eq!(err.code(), "non_empty");

pub const fn message(&self) -> &'static str

Returns the human-readable message.

Intended for logs and diagnostics, not for matching; the wording may change between releases.

Examples

use type_lib::ValidationError;

let err = ValidationError::new("non_empty", "value must not be empty");
assert_eq!(err.message(), "value must not be empty");

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 Error for ValidationError

Available on crate feature std only.

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 Hash for ValidationError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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 Copy for ValidationError

impl Eq for ValidationError

impl StructuralPartialEq for ValidationError