cumulo-dipa 0.1.2

dipa makes it easy to efficiently delta encode large Rust data structures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

/// Used for integer and float types excluding `u8` and `i8` since those two do not use Option
/// wrappers.
#[macro_export]
macro_rules! number_diff_impl_option_wrapped {
    ($num_ty:ty , $other:ty) => {
        impl<'s, 'e> crate::Diffable<'s, 'e, $other> for $num_ty {
            type Delta = Option<$num_ty>;

            type DeltaOwned = Option<$num_ty>;

            fn create_delta_towards(&self, end_state: &$other) -> CreatedDelta<Self::Delta> {
                let did_change = self != end_state;

                let delta = match *self == *end_state {
                    true => None,
                    false => Some(*end_state),
                };

                CreatedDelta { delta, did_change }
            }
        }
    };
}

#[macro_export]
macro_rules! number_patch_impl_option_wrapped {
    ($num_ty:ty, $patch: ty) => {
        impl crate::Patchable<$patch> for $num_ty {
            fn apply_patch(&mut self, patch: $patch) {
                if let Some(patch) = patch {
                    *self = patch;
                }
            }
        }
    };
}

/// Used for u8 and i8 since their diffs are not wrapped in Option.
/// TODO: Rename to single_byte_impl or something, since we use this for bools
#[macro_export]
macro_rules! number_diff_impl_u8_or_i8 {
    ($num_ty:ty, $other:ty) => {
        impl<'s, 'e> crate::Diffable<'s, 'e, $other> for $num_ty {
            type Delta = $num_ty;

            type DeltaOwned = $num_ty;

            fn create_delta_towards(&self, end_state: &$other) -> CreatedDelta<Self::Delta> {
                let did_change = *self != *end_state;

                crate::CreatedDelta {
                    delta: *end_state,
                    did_change,
                }
            }
        }
    };
}

#[macro_export]
macro_rules! number_patch_impl_u8_or_i8 {
    ($num_ty:ty, $patch: ty) => {
        impl crate::Patchable<$patch> for $num_ty {
            fn apply_patch(&mut self, patch: $patch) {
                *self = patch;
            }
        }
    };
}

#[macro_export]
macro_rules! number_patch_impl_mut_u8_or_i8 {
    ($num_ty:ty, $patch: ty) => {
        impl crate::Patchable<$patch> for $num_ty {
            fn apply_patch(&mut self, patch: $patch) {
                **self = patch;
            }
        }
    };
}