Trait Apply

pub trait Apply {
    type Parent;

    // Required method
    fn apply_to_base(
        &self,
        source: &mut Self::Parent,
        errs: &mut Vec<ApplyError>,
    );
}

A trait that must implemented by any type that results from a ‘diff’ operation. It allows the (child) ‘diff’ type to be ‘applied’ to the parent type, mutating the parent in place to result in the value which is was originally diffed against.

Generally the user will not need to implement this type, as it will be done by the derive(Diffable) macro

Required Associated Types

type Parent

Required Methods

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

Implementations on Foreign Types

impl<'a, K, V> Apply for BTreeMap<K, KvDiff<'a, V, V::Diff>>

where K: Ord + Eq + Clone, V: Diffable<'a> + Clone,

type Parent = BTreeMap<K, V>

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<'a, K, V> Apply for HashMap<K, KvDiff<'a, V, V::Diff>>

where K: Hash + Eq + Clone, V: Diffable<'a> + Clone,

type Parent = HashMap<K, V>

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A> Apply for (A,)

where A: Apply,

type Parent = (<A as Apply>::Parent,)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B> Apply for (A, B)

where A: Apply, B: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C> Apply for (A, B, C)

where A: Apply, B: Apply, C: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D> Apply for (A, B, C, D)

where A: Apply, B: Apply, C: Apply, D: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D, E> Apply for (A, B, C, D, E)

where A: Apply, B: Apply, C: Apply, D: Apply, E: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent, <E as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D, E, F> Apply for (A, B, C, D, E, F)

where A: Apply, B: Apply, C: Apply, D: Apply, E: Apply, F: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent, <E as Apply>::Parent, <F as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D, E, F, G> Apply for (A, B, C, D, E, F, G)

where A: Apply, B: Apply, C: Apply, D: Apply, E: Apply, F: Apply, G: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent, <E as Apply>::Parent, <F as Apply>::Parent, <G as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D, E, F, G, H> Apply for (A, B, C, D, E, F, G, H)

where A: Apply, B: Apply, C: Apply, D: Apply, E: Apply, F: Apply, G: Apply, H: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent, <E as Apply>::Parent, <F as Apply>::Parent, <G as Apply>::Parent, <H as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<A, B, C, D, E, F, G, H, I> Apply for (A, B, C, D, E, F, G, H, I)

where A: Apply, B: Apply, C: Apply, D: Apply, E: Apply, F: Apply, G: Apply, H: Apply, I: Apply,

type Parent = (<A as Apply>::Parent, <B as Apply>::Parent, <C as Apply>::Parent, <D as Apply>::Parent, <E as Apply>::Parent, <F as Apply>::Parent, <G as Apply>::Parent, <H as Apply>::Parent, <I as Apply>::Parent)

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<T> Apply for Option<T>

where T: Apply,

type Parent = Option<<T as Apply>::Parent>

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

impl<T> Apply for Box<T>

where T: Apply,

type Parent = Box<<T as Apply>::Parent>

fn apply_to_base(&self, source: &mut Self::Parent, errs: &mut Vec<ApplyError>)

Implementors

impl<'a, T> Apply for VecDiff<'a, T, T::Diff>

where T: Diffable<'a> + Clone,

type Parent = Vec<T>

impl<'a, T, U> Apply for DeepDiff<'a, T, U>

where T: Diffable<'a> + Clone, U: Apply<Parent = T>,

type Parent = T

impl<P> Apply for PatchOnlyDiff<P>

where P: Apply,

type Parent = <P as Apply>::Parent

impl<T> Apply for AtomicDiff<'_, T>

where T: Clone,

type Parent = T

impl<T> Apply for Id<T>

type Parent = T