Struct Validator

pub struct Validator { /* private fields */ }

A compiled JSON Schema validator.

This structure represents a JSON Schema that has been parsed and compiled into an efficient internal representation for validation. It contains the root node of the schema tree and the configuration options used during compilation.

Implementations

impl Validator

pub fn options() -> ValidationOptions

Create a default ValidationOptions for configuring JSON Schema validation.

Use this to set the draft version and other validation parameters.

Example

let validator = jsonschema::options()
    .with_draft(Draft::Draft7)
    .build(&schema);

pub fn new(schema: &Value) -> Result<Validator, ValidationError<'static>>

Create a validator using the default options.

pub fn compile(schema: &Value) -> Result<Validator, ValidationError<'static>>

👎Deprecated since 0.20.0: Use Validator::new instead

Create a validator using the default options.

DEPRECATED: Use Validator::new instead.

pub fn validate<'instance>( &'instance self, instance: &'instance Value, ) -> Result<(), ErrorIterator<'instance>>

Run validation against instance and return an iterator over ValidationError in the error case.

pub fn is_valid(&self, instance: &Value) -> bool

Run validation against instance but return a boolean result instead of an iterator. It is useful for cases, where it is important to only know the fact if the data is valid or not. This approach is much faster, than Validator::validate.

pub const fn apply<'a, 'b>(&'a self, instance: &'b Value) -> Output<'a, 'b>

Apply the schema and return an Output. No actual work is done at this point, the evaluation of the schema is deferred until a method is called on the Output. This is because different output formats will have different performance characteristics.

Examples

“basic” output format

use serde_json::json;

let schema = json!({
    "title": "string value",
    "type": "string"
});
let instance = json!("some string");

let validator = jsonschema::validator_for(&schema)
    .expect("Invalid schema");

let output = validator.apply(&instance).basic();
assert_eq!(
    serde_json::to_value(output)?,
    json!({
        "valid": true,
        "annotations": [
            {
                "keywordLocation": "",
                "instanceLocation": "",
                "annotations": {
                    "title": "string value"
                }
            }
        ]
    })
);

pub fn draft(&self) -> Draft

The Draft which was used to build this validator.

pub fn config(&self) -> Arc<ValidationOptions>

The ValidationOptions that were used to build this validator.

Trait Implementations

impl Debug for Validator

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

Formats the value using the given formatter.