Struct Validated 

pub struct Validated<T, V = ()> { /* private fields */ }

A value that might be invalid, together with its errors.

Deserializing a Validated never fails: the errors of the value are kept in it instead of failing the deserialization of the value it’s in. That covers the errors of the value itself (for instance a string where a number is expected), of the values nested in it and the violation of the validator V (none by default). Within the value, all errors are collected (see State::set_collect_errors): the error holds all problems of the value, not just the first one. Only the errors of the data format and of layers (for instance Limits) still fail the deserialization, and the error that exceeds the limit of errors (see State::set_max_errors).

use deser::Deserialize;
use deser_validate::{Email, Validated};

#[derive(Deserialize)]
struct Signup {
    email: Validated<String, Email>,
    age: Validated<u8>,
}

let signup: Signup =
    deser_json::from_str(r#"{"email": "nope", "age": "x"}"#).unwrap();
assert!(!signup.email.is_valid());
assert_eq!(signup.email.unchecked_value().unwrap(), "nope");
assert_eq!(
    signup.email.error().unwrap().to_string(),
    "InvalidValue: invalid value: must be an email address at offset 10"
);
assert_eq!(signup.age.value(), None);

The errors have the context of the value attached, like errors that are returned (for instance the path with a PathLayer). If the format provides the source (see deser_location), their lines and columns are resolved. If a Validation runs, they are reported to it too.

While an untagged enum tries its variants, errors are not kept: a variant with an invalid Validated value does not match.

use deser::Deserialize;
use deser_validate::Validated;

#[derive(Deserialize)]
struct Address {
    street: String,
    zip: u32,
}

#[derive(Deserialize)]
struct Order {
    shipping: Validated<Address>,
}

let order: Order =
    deser_json::from_str(r#"{"shipping": {"zip": "x"}}"#).unwrap();
let err = order.shipping.error().unwrap();
let errors: Vec<_> = err.errors().map(|err| err.message()).collect();
assert_eq!(
    errors,
    ["unexpected string, expected u32", "missing field `street`"]
);

When serialized, the value is serialized (also if it’s invalid), a value that could not be deserialized is serialized as null.

Implementations

impl<T, V: Validator<T>> Validated<T, V>

pub fn new(value: T) -> Validated<T, V>

Validates a value.

impl<T, V> Validated<T, V>

pub fn from_error(error: Error) -> Validated<T, V>

Creates an invalid value from an error.

pub fn is_valid(&self) -> bool

Returns true if the value is valid.

pub fn value(&self) -> Option<&T>

Returns the value if it’s valid.

pub fn unchecked_value(&self) -> Option<&T>

Returns the value, also if the validator rejected it.

Returns None if the value could not be deserialized.

pub fn error(&self) -> Option<&Error>

Returns the error if the value is invalid.

The error holds all errors of the value (see Error::errors).

pub fn into_result(self) -> Result<T, Error>

Returns the value if it’s valid and the error otherwise.

Trait Implementations

impl<T: Debug, V> Debug for Validated<T, V>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>, V: Validator<T>> Deserialize<'de> for Validated<T, V>

fn initial_value() -> Option<Self>

Missing values are the missing values of T (validated).

fn deserialize_into<'out>( out: &'out mut Option<Self>, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that deserializes the value into the given slot.

fn expecting() -> Cow<'static, str>

Returns what the value expects, for error messages.

fn describe_type(d: &mut dyn Describe)

Describes the Rust shape of the type.

fn deserialize_atom( slot: &mut Slot<T, Self>, atom: Atom<'_>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom into the slot.

fn deserialize_borrowed_atom( slot: &mut Slot<T, Self>, atom: Atom<'de>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom that borrows from the data being deserialized into the slot.

fn deserialize_update<'out>( value: &'out mut T, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that updates an existing value.

impl<T: Serialize, V> Serialize for Validated<T, V>

fn serialize<'a>(this: &'a Self, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn finish(this: &Self, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn is_optional(this: &Self) -> bool

Checks if the value represents an optional value.

fn container_shape(this: &Self) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.

fn describe(this: &Self, d: &mut dyn Describe)

Describes the Rust shape of the value.