delta-pack 0.2.1

Binary serialization with delta compression for real-time state synchronization
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// Auto-generated by DeltaPack - do not edit
#![allow(dead_code, unused_imports, clippy::all)]

use delta_pack::IndexMap;
use delta_pack::{Decoder, Encoder};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Primitives {
    #[serde(rename = "stringField")]
    pub string_field: String,
    #[serde(rename = "signedIntField")]
    pub signed_int_field: i64,
    #[serde(rename = "unsignedIntField")]
    pub unsigned_int_field: u64,
    #[serde(rename = "boundedIntField")]
    pub bounded_int_field: i64,
    #[serde(rename = "floatField")]
    pub float_field: f32,
    #[serde(rename = "booleanField")]
    pub boolean_field: bool,
}

impl Default for Primitives {
    fn default() -> Self {
        Self {
            string_field: String::new(),
            signed_int_field: 0,
            unsigned_int_field: 0,
            bounded_int_field: 0,
            float_field: 0.0,
            boolean_field: false,
        }
    }
}

impl Primitives {
    pub fn equals(&self, other: &Self) -> bool {
        self.string_field == other.string_field
            && self.signed_int_field == other.signed_int_field
            && self.unsigned_int_field == other.unsigned_int_field
            && self.bounded_int_field == other.bounded_int_field
            && delta_pack::equals_float(self.float_field, other.float_field)
            && self.boolean_field == other.boolean_field
    }

    pub fn encode(&self) -> Vec<u8> {
        Encoder::encode(|encoder| {
            self.encode_into(encoder);
            encoder.finish()
        })
    }

    pub fn encode_into(&self, encoder: &mut Encoder) {
        encoder.push_string(&self.string_field);
        encoder.push_int(self.signed_int_field);
        encoder.push_uint(self.unsigned_int_field);
        encoder.push_enum((self.bounded_int_field - (-10)) as u32, 5);
        encoder.push_float(self.float_field);
        encoder.push_boolean(self.boolean_field);
    }

    pub fn encode_diff(a: &Self, b: &Self) -> Vec<u8> {
        Encoder::encode(|encoder| {
            encoder.push_object_diff(
                a,
                b,
                |x, y| x.equals(y),
                |enc| {
                    Self::encode_diff_into(a, b, enc);
                },
            );
            encoder.finish()
        })
    }

    pub fn encode_diff_into(a: &Self, b: &Self, encoder: &mut Encoder) {
        encoder.push_field_diff(
            &a.string_field,
            &b.string_field,
            |x, y| x == y,
            |enc, a, b| enc.push_string_diff(a, b),
        );
        encoder.push_field_diff(
            &a.signed_int_field,
            &b.signed_int_field,
            |x, y| x == y,
            |enc, &a, &b| enc.push_int_diff(a, b),
        );
        encoder.push_field_diff(
            &a.unsigned_int_field,
            &b.unsigned_int_field,
            |x, y| x == y,
            |enc, &a, &b| enc.push_uint_diff(a, b),
        );
        encoder.push_field_diff(
            &a.bounded_int_field,
            &b.bounded_int_field,
            |x, y| x == y,
            |enc, &a, &b| enc.push_enum_diff((a - (-10)) as u32, (b - (-10)) as u32, 5),
        );
        encoder.push_field_diff(
            &a.float_field,
            &b.float_field,
            |x, y| delta_pack::equals_float(*x, *y),
            |enc, &a, &b| enc.push_float_diff(a, b),
        );
        encoder.push_boolean_diff(a.boolean_field, b.boolean_field);
    }

    pub fn decode(buf: &[u8]) -> Self {
        Decoder::decode(buf, |decoder| Self::decode_from(decoder))
    }

    pub fn decode_from(decoder: &mut Decoder) -> Self {
        Self {
            string_field: decoder.next_string(),
            signed_int_field: decoder.next_int(),
            unsigned_int_field: decoder.next_uint(),
            bounded_int_field: decoder.next_enum(5) as i64 + (-10),
            float_field: decoder.next_float(),
            boolean_field: decoder.next_boolean(),
        }
    }

    pub fn decode_diff(obj: &Self, diff: &[u8]) -> Self {
        Decoder::decode(diff, |decoder| {
            decoder.next_object_diff(obj, |dec| Self::decode_diff_from(obj, dec))
        })
    }

    pub fn decode_diff_from(obj: &Self, decoder: &mut Decoder) -> Self {
        Self {
            string_field: decoder
                .next_field_diff(&obj.string_field, |dec, a| dec.next_string_diff(a)),
            signed_int_field: decoder
                .next_field_diff(&obj.signed_int_field, |dec, &a| dec.next_int_diff(a)),
            unsigned_int_field: decoder
                .next_field_diff(&obj.unsigned_int_field, |dec, &a| dec.next_uint_diff(a)),
            bounded_int_field: decoder.next_field_diff(&obj.bounded_int_field, |dec, &a| {
                dec.next_enum_diff((a - (-10)) as u32, 5) as i64 + (-10)
            }),
            float_field: decoder
                .next_field_diff(&obj.float_field, |dec, &a| dec.next_float_diff(a)),
            boolean_field: decoder.next_boolean_diff(obj.boolean_field),
        }
    }
}