Trait Diff

pub trait Diff<With, Output, Context: DiffContext> {
    // Required method
    fn diff(&self, new: Option<&With>, context: &Context) -> DiffResult<Output>;
}

Required Methods

fn diff(&self, new: Option<&With>, context: &Context) -> DiffResult<Output>

Implementations on Foreign Types

impl<C: DiffContext> Diff<Value, Value, C> for Value

fn diff(&self, new: Option<&Value>, context: &C) -> DiffResult<Value>

impl<C: DiffContext> Diff<bool, bool, C> for bool

fn diff(&self, new: Option<&bool>, context: &C) -> DiffResult<bool>

impl<C: DiffContext> Diff<f32, f32, C> for f32

fn diff(&self, new: Option<&f32>, context: &C) -> DiffResult<f32>

impl<C: DiffContext> Diff<f64, f64, C> for f64

fn diff(&self, new: Option<&f64>, context: &C) -> DiffResult<f64>

impl<C: DiffContext> Diff<i32, i32, C> for i32

fn diff(&self, new: Option<&i32>, context: &C) -> DiffResult<i32>

impl<C: DiffContext> Diff<i64, i64, C> for i64

fn diff(&self, new: Option<&i64>, context: &C) -> DiffResult<i64>

impl<C: DiffContext> Diff<u32, u32, C> for u32

fn diff(&self, new: Option<&u32>, context: &C) -> DiffResult<u32>

impl<C: DiffContext> Diff<u64, u64, C> for u64

fn diff(&self, new: Option<&u64>, context: &C) -> DiffResult<u64>

impl<C: DiffContext> Diff<usize, usize, C> for usize

fn diff(&self, new: Option<&usize>, context: &C) -> DiffResult<usize>

impl<C: DiffContext> Diff<String, String, C> for String

fn diff(&self, new: Option<&String>, context: &C) -> DiffResult<String>

impl<T, O, C: DiffContext> Diff<T, O, C> for Option<T>

where T: Diff<T, O, C> + Debug,

fn diff(&self, new: Option<&T>, context: &C) -> DiffResult<O>

impl<T, O, C: DiffContext, S> Diff<Vec<T>, VecDiff<O, S>, C> for Vec<T>

where T: Diff<T, O, C> + Keyed<usize> + Debug, S: VecDiffTransformer<Vec<DiffResult<O>>>, O: Debug,

fn diff(&self, new: Option<&Vec<T>>, context: &C) -> DiffResult<VecDiff<O, S>>

impl<V, O, C, R> Diff<IndexMap<String, V>, MapDiff<O, R>, C> for IndexMap<String, V>

where V: Diff<V, O, C> + Clone + Debug, R: PathResolver, C: DiffContext, O: Debug,

fn diff( &self, new: Option<&IndexMap<String, V>>, context: &C, ) -> DiffResult<MapDiff<O, R>>

Implementors

impl Diff<Components, ComponentsDiff, HttpSchemaDiffContext> for Components

impl Diff<Contact, ContactDiff, HttpSchemaDiffContext> for Contact

impl Diff<Discriminator, DiscriminatorDiff, HttpSchemaDiffContext> for Discriminator

impl Diff<Encoding, EncodingDiff, HttpSchemaDiffContext> for Encoding

impl Diff<Example, ExampleDiff, HttpSchemaDiffContext> for Example

impl Diff<ExternalDoc, ExternalDocDiff, HttpSchemaDiffContext> for ExternalDoc

impl Diff<Header, HeaderDiff, HttpSchemaDiffContext> for Header

impl Diff<HttpSchema, HttpSchemaDiff, HttpSchemaDiffContext> for HttpSchema

impl Diff<Info, InfoDiff, HttpSchemaDiffContext> for Info

impl Diff<License, LicenseDiff, HttpSchemaDiffContext> for License

impl Diff<Link, LinkDiff, HttpSchemaDiffContext> for Link

impl Diff<MediaType, MediaTypeDiff, HttpSchemaDiffContext> for MediaType

impl Diff<OAuthFlow, OAuthFlowDiff, HttpSchemaDiffContext> for OAuthFlow

impl Diff<OAuthFlows, OAuthFlowsDiff, HttpSchemaDiffContext> for OAuthFlows

impl Diff<Operation, OperationDiff, HttpSchemaDiffContext> for Operation

impl Diff<Parameter, ParameterDiff, HttpSchemaDiffContext> for Parameter

impl Diff<Path, PathDiff, HttpSchemaDiffContext> for Path

impl Diff<RequestBody, RequestBodyDiff, HttpSchemaDiffContext> for RequestBody

impl Diff<Response, ResponseDiff, HttpSchemaDiffContext> for Response

impl Diff<Schema, SchemaDiff, HttpSchemaDiffContext> for Schema

impl Diff<SecurityScheme, SecuritySchemeDiff, HttpSchemaDiffContext> for SecurityScheme

impl Diff<Server, ServerDiff, HttpSchemaDiffContext> for Server

impl Diff<ServerVariable, ServerVariableDiff, HttpSchemaDiffContext> for ServerVariable

impl Diff<Tag, TagDiff, HttpSchemaDiffContext> for Tag

impl Diff<Xml, XmlDiff, HttpSchemaDiffContext> for Xml

impl<L, R, LD, RD, C: DiffContext> Diff<Either<L, R>, EitherDiff<LD, RD>, C> for Either<L, R>

where L: Diff<L, LD, C>, R: Diff<R, RD, C>,

impl<T, O, R, C> Diff<MayBeRefCore<T, R>, MayBeRefCoreDiff<O, R>, C> for MayBeRefCore<T, R>

where T: Diff<T, O, C> + Clone + Debug + 'static, O: Referencable + Clone + Debug + 'static, R: ReferenceDescriptor + Clone + Debug + 'static, C: DiffContext + ComponentContainer<T> + DiffCache<O> + ToOwned<Owned = C>,