Enum ValidationError

pub enum ValidationError {
    Schema {
        code: &'static str,
        message: Option<String>,
        location: String,
    },
    Field {
        field: Option<&'static str>,
        code: &'static str,
        params: Box<HashMap<&'static str, Value>>,
        message: Option<String>,
        location: String,
    },
}

Variants

Schema

Fields

code: &'static str

The ‘code’ usually indicating what type of validation failed

message: Option<String>

An optional message for the error

location: String

Where in the struct the validation failed. Similar to JSON pointers. Always ‘/’ for schema.

Field

Fields

field: Option<&'static str>

The name of the field

code: &'static str

The ‘code’ usually indicating what type of validation failed

params: Box<HashMap<&'static str, Value>>

The parameters used to specify the exact cause of validation failure. Will usually be actual and target.

message: Option<String>

An optional message for the error

location: String

Where in the struct the validation failed. Similar to JSON pointers.

Implementations

impl ValidationError

pub fn new_field(code: &'static str) -> ValidationError

Creates a new field validation error. This should be used when returning errors from reusable custom functions as validify will automatically set field names.

pub fn new_field_named( field: &'static str, code: &'static str, ) -> ValidationError

Creates a new field error with the given field name and code.

pub fn new_schema(code: &'static str) -> ValidationError

Creates a new schema error with the given code

pub fn set_field(&mut self, field: &'static str)

Set the field name to the given one if the error is a field error

pub fn field_name(&self) -> Option<&str>

Get the error’s field name if it was a field error

pub fn add_param<T: Serialize>(&mut self, name: &'static str, val: &T)

pub fn with_param<T: Serialize>(self, name: &'static str, val: &T) -> Self

pub fn with_message(self, msg: String) -> Self

pub fn set_location<T>(&mut self, parent: T)

where T: Display,

Insert the provided parent to the 0th position of the current location

pub fn append_location<T>(&mut self, child: T)

where T: Display,

Append the provided parent to the current location

pub fn set_location_idx<T: Display>(&mut self, idx: T, parent: &str)

Used when the struct failing validation is nested in collections. It will concat the index to the parent so as to follow the location.

pub fn location(&self) -> &str

Returns the absolute location of the error in a similiar manner to JSON pointers.

pub fn params(&self) -> HashMap<&'static str, Value>

pub fn code(&self) -> String

pub fn message(&self) -> Option<String>

pub fn set_message(&mut self, msg: String)

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 Deserialize<'static> for ValidationError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'static>,

Deserialize this value from the given Serde deserializer.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Error for ValidationError

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 source(&self) -> Option<&(dyn Error + 'static)>

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

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ValidationError

impl StructuralPartialEq for ValidationError