Struct SchemaDiff

pub struct SchemaDiff {

    pub title: DiffResult<String>,
    pub multiple_of: DiffResult<f32>,
    pub maximum: DiffResult<f32>,
    pub exclusive_maximum: DiffResult<bool>,
    pub minimum: DiffResult<f32>,
    pub exclusive_minimum: DiffResult<bool>,
    pub max_length: DiffResult<usize>,
    pub min_length: DiffResult<usize>,
    pub pattern: DiffResult<String>,
    pub max_items: DiffResult<usize>,
    pub min_items: DiffResult<usize>,
    pub unique_items: DiffResult<bool>,
    pub max_properties: DiffResult<usize>,
    pub min_properties: DiffResult<usize>,
    pub required: DiffResult<VecDiff<String>>,
    pub enum: DiffResult<VecDiff<Value>>,
    pub type: DiffResult<EitherDiff<String, VecDiff<String, TypeVecDiffSorter>>>,
    pub all_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>,
    pub one_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>,
    pub any_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>,
    pub not: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>,
    pub items: Box<DiffResult<MayBeRefDiff<SchemaDiff>>>,
    pub properties: DiffResult<MapDiff<MayBeRefDiff<SchemaDiff>>>,
    pub additional_properties: DiffResult<EitherDiff<bool, MayBeRefDiff<SchemaDiff>>>,
    pub description: DiffResult<String>,
    pub format: DiffResult<String>,
    pub default: DiffResult<Value>,
    pub discriminator: DiffResult<DiscriminatorDiff>,
    pub read_only: DiffResult<bool>,
    pub write_only: DiffResult<bool>,
    pub xml: DiffResult<XmlDiff>,
    pub external_docs: DiffResult<ExternalDocDiff>,
    pub example: DiffResult<Value>,
    pub deprecated: DiffResult<bool>,
    pub custom_fields: DiffResult<MapDiff<Value>>,
}

Fields

title: DiffResult<String>

multiple_of: DiffResult<f32>

maximum: DiffResult<f32>

exclusive_maximum: DiffResult<bool>

minimum: DiffResult<f32>

exclusive_minimum: DiffResult<bool>

max_length: DiffResult<usize>

min_length: DiffResult<usize>

pattern: DiffResult<String>

max_items: DiffResult<usize>

min_items: DiffResult<usize>

unique_items: DiffResult<bool>

max_properties: DiffResult<usize>

min_properties: DiffResult<usize>

required: DiffResult<VecDiff<String>>

enum: DiffResult<VecDiff<Value>>

type: DiffResult<EitherDiff<String, VecDiff<String, TypeVecDiffSorter>>>

all_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>

one_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>

any_of: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>

not: DiffResult<VecDiff<MayBeRefDiff<SchemaDiff>>>

items: Box<DiffResult<MayBeRefDiff<SchemaDiff>>>

properties: DiffResult<MapDiff<MayBeRefDiff<SchemaDiff>>>

additional_properties: DiffResult<EitherDiff<bool, MayBeRefDiff<SchemaDiff>>>

description: DiffResult<String>

format: DiffResult<String>

default: DiffResult<Value>

discriminator: DiffResult<DiscriminatorDiff>

read_only: DiffResult<bool>

write_only: DiffResult<bool>

xml: DiffResult<XmlDiff>

external_docs: DiffResult<ExternalDocDiff>

example: DiffResult<Value>

deprecated: DiffResult<bool>

custom_fields: DiffResult<MapDiff<Value>>

Trait Implementations

impl Clone for SchemaDiff

fn clone(&self) -> SchemaDiff

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SchemaDiff

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SchemaDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Diff<Schema, SchemaDiff, HttpSchemaDiffContext> for Schema

fn diff( &self, new: Option<&Schema>, context: &HttpSchemaDiffContext, ) -> DiffResult<SchemaDiff>

impl DiffCache<SchemaDiff> for HttpSchemaDiffContext

fn get_diff(&self, reference: &str) -> Option<Arc<DiffResult<SchemaDiff>>>

fn set_diff(&self, reference: &str, component: Arc<DiffResult<SchemaDiff>>)

impl DiffOwnChanges for SchemaDiff

fn get_own_changes(&self) -> Vec<(Cow<'_, str>, DiffResultType)>

impl Empty for SchemaDiff

fn is_empty(&self) -> bool

impl Serialize for SchemaDiff

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Referencable for SchemaDiff