Enum jtd::SchemaValidateError

pub enum SchemaValidateError {
    NoSuchDefinition(String),
    NonRootDefinitions,
    EmptyEnum,
    RepeatedProperty(String),
    NullableMapping,
    NonPropertiesMapping,
    RepeatedDiscriminator(String),
}

Errors that may arise from Schema::validate.

Variants

NoSuchDefinition(String)

Indicates the schema has a ref to a definition that doesn't exist.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::NoSuchDefinition("foo".into())),

    // a "ref" without definitions is always invalid
    Schema::Ref {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        ref_: "foo".into(),
    }.validate(),
)

NonRootDefinitions

Indicates the schema has non-empty definitions below the root level.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::NonRootDefinitions),

    // definitions can only be present at the root level
    Schema::Elements {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        elements: Box::new(Schema::Empty {
            definitions: vec![(
                "foo".to_owned(),
                Schema::Empty {
                    definitions: Default::default(),
                    metadata: Default::default(),
                }
            )].into_iter().collect(),
            metadata: Default::default(),
        }),
    }.validate(),
)

EmptyEnum

Indicates the schema has an enum with no values in it.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::EmptyEnum),

    // empty enums are illegal
    Schema::Enum {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        enum_: Default::default(),
    }.validate(),
)

RepeatedProperty(String)

Indicates the schema has the same property appear in properties and optional_properties.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::RepeatedProperty("foo".into())),

    // properties and optional_properties must not overlap
    Schema::Properties {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        properties: vec![(
            "foo".to_owned(),
            Schema::Empty {
                definitions: Default::default(),
                metadata: Default::default(),
            },
        )].into_iter().collect(),
        optional_properties: vec![(
            "foo".to_owned(),
            Schema::Empty {
                definitions: Default::default(),
                metadata: Default::default(),
            },
        )].into_iter().collect(),
        properties_is_present: true,
        additional_properties: false,
    }.validate(),
)

NullableMapping

Indicates the schema has a value in mapping with nullable set to true.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::NullableMapping),

    // mappings must not be nullable
    Schema::Discriminator {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        discriminator: "foo".into(),
        mapping: vec![(
            "bar".to_owned(),
            Schema::Properties {
                definitions: Default::default(),
                metadata: Default::default(),
                nullable: true,
                properties: Default::default(),
                optional_properties: Default::default(),
                properties_is_present: true,
                additional_properties: false,
            }
        )].into_iter().collect(),
    }.validate(),
);

NonPropertiesMapping

Indicates the schema has a value in mapping that isn't a Schema::Properties.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::NonPropertiesMapping),

    // mappings must be of the properties form
    Schema::Discriminator {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        discriminator: "foo".into(),
        mapping: vec![(
            "bar".to_owned(),
            Schema::Empty {
                definitions: Default::default(),
                metadata: Default::default(),
            }
        )].into_iter().collect(),
    }.validate(),
);

RepeatedDiscriminator(String)

Indicates the schema has a value in mapping whose properties or optional_properties contains discriminator.

use jtd::{Schema, SchemaValidateError};

assert_eq!(
    Err(SchemaValidateError::RepeatedDiscriminator("foo".into())),

    // mappings must not re-define the discriminator property
    Schema::Discriminator {
        definitions: Default::default(),
        metadata: Default::default(),
        nullable: Default::default(),
        discriminator: "foo".into(),
        mapping: vec![(
            "bar".to_owned(),
            Schema::Properties {
                definitions: Default::default(),
                metadata: Default::default(),
                nullable: Default::default(),
                properties: vec![(
                    "foo".into(),
                    Schema::Empty {
                        definitions: Default::default(),
                        metadata: Default::default(),
                    }
                )].into_iter().collect(),
                optional_properties: Default::default(),
                properties_is_present: true,
                additional_properties: false,
            }
        )].into_iter().collect(),
    }.validate(),
);

Trait Implementations

impl Clone for SchemaValidateError

fn clone(&self) -> SchemaValidateError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SchemaValidateError

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

Formats the value using the given formatter.

impl Display for SchemaValidateError

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

Formats the value using the given formatter.

impl Eq for SchemaValidateError

impl Error for SchemaValidateError

pub fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

pub fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

pub fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl PartialEq<SchemaValidateError> for SchemaValidateError

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for SchemaValidateError

impl StructuralPartialEq for SchemaValidateError