Enum Difference 

pub enum Difference {
    MissingKey {
        path: String,
        key: String,
        present_in: Side,
    },
    KindMismatch {
        path: String,
        left: &'static str,
        right: &'static str,
    },
    ValueMismatch {
        path: String,
        left: String,
        right: String,
    },
    TagMismatch {
        path: String,
        left: Option<String>,
        right: Option<String>,
    },
    LengthMismatch {
        path: String,
        left: usize,
        right: usize,
    },
}

One way in which two documents differ.

Variants

MissingKey

A mapping key present on one side only.

Fields

path: String

Where in the tree.

key: String

The key that is absent from the other side.

present_in: Side

The side that has the key.

KindMismatch

The two nodes are different kinds of thing.

Fields

path: String

Where in the tree.

left: &'static str

The left node’s kind.

right: &'static str

The right node’s kind.

ValueMismatch

Two scalars resolve to different values.

Fields

path: String

Where in the tree.

left: String

The left value, as written.

right: String

The right value, as written.

TagMismatch

The nodes carry different tags.

Fields

path: String

Where in the tree.

left: Option<String>

The left tag, if any.

right: Option<String>

The right tag, if any.

LengthMismatch

Two sequences have different lengths.

Fields

path: String

Where in the tree.

left: usize

The left length.

right: usize

The right length.

Implementations

impl Difference

pub fn path(&self) -> &str

Where in the tree this difference is.

Trait Implementations

impl Clone for Difference

fn clone(&self) -> Difference

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Difference

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

Formats the value using the given formatter.

impl Display for Difference

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

Formats the value using the given formatter.

impl PartialEq for Difference

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Difference