Enum ValidationErrorKind 

pub enum ValidationErrorKind {
    TooLong {
        len: usize,
        max: usize,
    },
    TooManyItems {
        len: usize,
        max: usize,
    },
    TooFewItems {
        len: usize,
        min: usize,
    },
    BelowMinimum {
        value: f64,
        min: f64,
    },
    AboveMaximum {
        value: f64,
        max: f64,
    },
    NotMultipleOf {
        value: f64,
        multiple: f64,
    },
}

What was wrong with the value.

The numeric variants carry f64 for uniformity across integer and number fields; comparison itself is done in the field’s own type, so an integer bound is never decided in floating point.

Variants

TooLong

A string longer than its schema’s maxLength, counted in characters.

Fields

len: usize

max: usize

TooManyItems

An array longer than its schema’s maxItems.

Fields

len: usize

max: usize

TooFewItems

An array shorter than its schema’s minItems.

Fields

len: usize

min: usize

BelowMinimum

A number below its schema’s minimum.

Fields

value: f64

min: f64

AboveMaximum

A number above its schema’s maximum.

Fields

value: f64

max: f64

NotMultipleOf

A number that is not a whole multiple of its schema’s multipleOf.

Fields

value: f64

multiple: f64

Implementations

impl ValidationErrorKind

pub fn constraint_class(&self) -> ConstraintClass

Which OCPP constraint category this violates, and so which CALLERROR code answers it. See ConstraintClass.

Examples found in repository

examples/validate.rs (line 42)

fn main() {
    let mut request: AuthorizeRequest = AuthorizeRequest {
        certificate: None,
        custom_data: None,
        id_token: IdToken {
            additional_info: None,
            custom_data: None,
            // Bounded at `maxLength: 36` by the schema, so this is a
            // `heapless::String<36>` and an over-long value can't be built
            // in the first place -- nothing for `validate` to check.
            id_token: heapless::String::try_from("ABC123").unwrap(),
            r#type: IdTokenEnum::ISO14443,
        },
        iso15118_certificate_hash_data: None,
    };

    println!("conformant: {:?}", request.validate());

    // `certificate` is `maxLength: 5500` in the schema, but 5500 is too
    // large to inline as a `heapless::String`, so with `alloc` it is a
    // plain growable `String`. The type accepts this; the spec does not.
    request.certificate = Some("-".repeat(6000));

    match request.validate() {
        Ok(()) => println!("no violations"),
        Err(error) => {
            println!("rejected: {error}");
            println!("  kind:    {:?}", error.kind());
            println!("  path:    {:?}", error.path());

            // Which `CALLERROR` a CSMS answers with. The code's spelling is
            // version-specific (1.6J dropped an `r` from "occurrence"), so
            // the classification is what's shared.
            let code = match error.kind().constraint_class() {
                ConstraintClass::Property => "PropertyConstraintViolation",
                ConstraintClass::Occurrence => "OccurrenceConstraintViolation",
            };
            println!("  answer:  {code}");
        }
    }

    // `minItems: 1` is the other half: no collection type can say "at least
    // one", so an empty required array is only caught here.
    request.certificate = None;
    request.iso15118_certificate_hash_data = Some(heapless::Vec::new());

    if let Err(error) = request.validate() {
        println!("rejected: {error}");
    }
}

Trait Implementations

impl Clone for ValidationErrorKind

fn clone(&self) -> ValidationErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ValidationErrorKind

impl Debug for ValidationErrorKind

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

Formats the value using the given formatter.

impl Display for ValidationErrorKind

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

Formats the value using the given formatter.

impl PartialEq for ValidationErrorKind

fn eq(&self, other: &ValidationErrorKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ValidationErrorKind