Crate deltastruct

Create custom serializable changes to apply later

Deltastruct is an attribute macro that generates definitions for serializable changes (called deltas) over structs recursively.

For techinical reasons, the attribute macro must be applied to a mod definition containing a struct with the same name and an impl for it's change definitions. Function names are converted to camel case to appease the compiler.

The generated deltas are always the type name followed by Delta. ie: Foo -> FooDelta, i32 -> i32Delta.

#[deltastruct]
mod Vector3 {
  #[derive(Clone, Copy)]
  pub struct Vector3 {
    pub x : f64,
    pub y : f64,
    pub z : f64,
  }

  impl Vector3 {
    fn set(&mut self, other : Vector3) {
      // Copy the given vec's components into our own.
      self.x = other.x;
      self.y = other.y;
      self.z = other.z;
    }

    fn multiply_scalar(&mut self, n : f64) {
      // Multiply each component by the given value
      self.x *= n;
      self.y *= n;
      self.z *= n;
    }

    fn normalize(&mut self) {
      // divide each component by the vector's magnitude
      let magnitude = (
          self.x.powf(2f64)
        + self.y.powf(2f64)
        + self.z.powf(2f64)
      ).sqrt();
       
      self.x /= magnitude;
      self.y /= magnitude;
      self.z /= magnitude;
    }
  }
}

fn main() {
  let mut v = Vector3 {
    x: 3f64,
    y: 6f64,
    z: 6f64
  };


  let v_delta = Vector3Delta::MultiplyScalar(4f64);
  v.apply(&v_delta);
  v.apply(&v_delta);

  assert_eq!(v.x, 48f64);


  let v_delta = Vector3Delta::Normalize();
  v.apply(&v_delta);

  assert_eq!(v.z, 2f64/3f64);


  let v_delta = Vector3Delta::X(f64Delta::Set(8f64));
  v.apply(&v_delta);

  assert_eq!(v.x, 8f64);
}

Enums

HashMapDelta
HashSetDelta
OptionDelta
StringDelta
VecDelta
boolDelta
charDelta
f32Delta
f64Delta
i8Delta
i16Delta
i32Delta
i64Delta
isizeDelta
u8Delta
u16Delta
u32Delta
u64Delta
usizeDelta

Traits

DeltaStruct

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

Attribute Macros

deltastruct

An attribute macro applied to mods. Will generate a Delta and it's DeltaStruct<_> implementation.