Trait deltastruct::DeltaStruct

pub trait DeltaStruct<T> {
    fn apply(&mut self, delta: &T);
}

A trait derived for each tagged struct where T is it's generated delta.

#[deltastruct]
mod Foo {
  struct Foo {
    bar : bool
  }
  impl Foo {
    fn foobar(&mut self) {}
  }
}

will generate:

impl DeltaStruct<FooDelta> for Foo {
  fn apply(&mut self, delta : &FooDelta) {
    /* ... */
  }
}

Required methods

fn apply(&mut self, delta: &T)

Loading content...

Implementations on Foreign Types

impl DeltaStruct<i8Delta> for i8

fn apply(&mut self, delta: &i8Delta)

impl DeltaStruct<i16Delta> for i16

fn apply(&mut self, delta: &i16Delta)

impl DeltaStruct<i32Delta> for i32

fn apply(&mut self, delta: &i32Delta)

impl DeltaStruct<i64Delta> for i64

fn apply(&mut self, delta: &i64Delta)

impl DeltaStruct<u8Delta> for u8

fn apply(&mut self, delta: &u8Delta)

impl DeltaStruct<u16Delta> for u16

fn apply(&mut self, delta: &u16Delta)

impl DeltaStruct<u32Delta> for u32

fn apply(&mut self, delta: &u32Delta)

impl DeltaStruct<u64Delta> for u64

fn apply(&mut self, delta: &u64Delta)

impl DeltaStruct<usizeDelta> for usize

fn apply(&mut self, delta: &usizeDelta)

impl DeltaStruct<isizeDelta> for isize

fn apply(&mut self, delta: &isizeDelta)

impl DeltaStruct<f32Delta> for f32

fn apply(&mut self, delta: &f32Delta)

impl DeltaStruct<f64Delta> for f64

fn apply(&mut self, delta: &f64Delta)

impl DeltaStruct<boolDelta> for bool

fn apply(&mut self, delta: &boolDelta)

impl DeltaStruct<charDelta> for char

fn apply(&mut self, delta: &charDelta)

impl DeltaStruct<StringDelta> for String

fn apply(&mut self, delta: &StringDelta)

impl<T> DeltaStruct<VecDelta<T>> for Vec<T> where
    T: Clone, 

fn apply(&mut self, delta: &VecDelta<T>)

impl<T> DeltaStruct<OptionDelta<T>> for Option<T> where
    T: Clone, 

fn apply(&mut self, delta: &OptionDelta<T>)

impl<T> DeltaStruct<HashSetDelta<T>> for HashSet<T> where
    T: Clone + Eq + Hash, 

fn apply(&mut self, delta: &HashSetDelta<T>)

impl<T, U> DeltaStruct<HashMapDelta<T, U>> for HashMap<T, U> where
    T: Clone + Eq + Hash,
    U: Clone, 

fn apply(&mut self, delta: &HashMapDelta<T, U>)

Loading content...

Implementors

Loading content...