protobuf/
unknown.rs

1use std::collections::hash_map;
2use std::collections::hash_map::DefaultHasher;
3use std::collections::HashMap;
4use std::default::Default;
5use std::hash::BuildHasherDefault;
6use std::hash::Hash;
7use std::hash::Hasher;
8use std::slice;
9
10use crate::clear::Clear;
11use crate::wire_format;
12use crate::zigzag::encode_zig_zag_32;
13use crate::zigzag::encode_zig_zag_64;
14
15/// Unknown value.
16///
17/// See [`UnknownFields`](crate::UnknownFields) for the explanations.
18#[derive(Debug)]
19pub enum UnknownValue {
20    /// 32-bit unknown (e. g. `fixed32` or `float`)
21    Fixed32(u32),
22    /// 64-bit unknown (e. g. `fixed64` or `double`)
23    Fixed64(u64),
24    /// Varint unknown (e. g. `int32` or `bool`)
25    Varint(u64),
26    /// Length-delimited unknown (e. g. `message` or `string`)
27    LengthDelimited(Vec<u8>),
28}
29
30impl UnknownValue {
31    /// Wire type for this unknown
32    pub fn wire_type(&self) -> wire_format::WireType {
33        self.get_ref().wire_type()
34    }
35
36    /// As ref
37    pub fn get_ref<'s>(&'s self) -> UnknownValueRef<'s> {
38        match *self {
39            UnknownValue::Fixed32(fixed32) => UnknownValueRef::Fixed32(fixed32),
40            UnknownValue::Fixed64(fixed64) => UnknownValueRef::Fixed64(fixed64),
41            UnknownValue::Varint(varint) => UnknownValueRef::Varint(varint),
42            UnknownValue::LengthDelimited(ref bytes) => UnknownValueRef::LengthDelimited(&bytes),
43        }
44    }
45
46    /// Construct unknown value from `sint32` value.
47    pub fn sint32(i: i32) -> UnknownValue {
48        UnknownValue::Varint(encode_zig_zag_32(i) as u64)
49    }
50
51    /// Construct unknown value from `sint64` value.
52    pub fn sint64(i: i64) -> UnknownValue {
53        UnknownValue::Varint(encode_zig_zag_64(i))
54    }
55}
56
57/// Reference to unknown value.
58///
59/// See [`UnknownFields`](crate::UnknownFields) for explanations.
60pub enum UnknownValueRef<'o> {
61    /// 32-bit unknown
62    Fixed32(u32),
63    /// 64-bit unknown
64    Fixed64(u64),
65    /// Varint unknown
66    Varint(u64),
67    /// Length-delimited unknown
68    LengthDelimited(&'o [u8]),
69}
70
71impl<'o> UnknownValueRef<'o> {
72    /// Wire-type to serialize this unknown
73    pub fn wire_type(&self) -> wire_format::WireType {
74        match *self {
75            UnknownValueRef::Fixed32(_) => wire_format::WireTypeFixed32,
76            UnknownValueRef::Fixed64(_) => wire_format::WireTypeFixed64,
77            UnknownValueRef::Varint(_) => wire_format::WireTypeVarint,
78            UnknownValueRef::LengthDelimited(_) => wire_format::WireTypeLengthDelimited,
79        }
80    }
81}
82
83/// Field unknown values.
84///
85/// See [`UnknownFields`](crate::UnknownFields) for explanations.
86#[derive(Clone, PartialEq, Eq, Debug, Default, Hash)]
87pub struct UnknownValues {
88    /// 32-bit unknowns
89    pub fixed32: Vec<u32>,
90    /// 64-bit unknowns
91    pub fixed64: Vec<u64>,
92    /// Varint unknowns
93    pub varint: Vec<u64>,
94    /// Length-delimited unknowns
95    pub length_delimited: Vec<Vec<u8>>,
96}
97
98impl UnknownValues {
99    /// Add unknown value
100    pub fn add_value(&mut self, value: UnknownValue) {
101        match value {
102            UnknownValue::Fixed64(fixed64) => self.fixed64.push(fixed64),
103            UnknownValue::Fixed32(fixed32) => self.fixed32.push(fixed32),
104            UnknownValue::Varint(varint) => self.varint.push(varint),
105            UnknownValue::LengthDelimited(length_delimited) => {
106                self.length_delimited.push(length_delimited)
107            }
108        };
109    }
110
111    /// Iterate over unknown values
112    pub fn iter<'s>(&'s self) -> UnknownValuesIter<'s> {
113        UnknownValuesIter {
114            fixed32: self.fixed32.iter(),
115            fixed64: self.fixed64.iter(),
116            varint: self.varint.iter(),
117            length_delimited: self.length_delimited.iter(),
118        }
119    }
120}
121
122impl<'a> IntoIterator for &'a UnknownValues {
123    type Item = UnknownValueRef<'a>;
124    type IntoIter = UnknownValuesIter<'a>;
125
126    fn into_iter(self) -> UnknownValuesIter<'a> {
127        self.iter()
128    }
129}
130
131/// Iterator over unknown values
132pub struct UnknownValuesIter<'o> {
133    fixed32: slice::Iter<'o, u32>,
134    fixed64: slice::Iter<'o, u64>,
135    varint: slice::Iter<'o, u64>,
136    length_delimited: slice::Iter<'o, Vec<u8>>,
137}
138
139impl<'o> Iterator for UnknownValuesIter<'o> {
140    type Item = UnknownValueRef<'o>;
141
142    fn next(&mut self) -> Option<UnknownValueRef<'o>> {
143        let fixed32 = self.fixed32.next();
144        if fixed32.is_some() {
145            return Some(UnknownValueRef::Fixed32(*fixed32.unwrap()));
146        }
147        let fixed64 = self.fixed64.next();
148        if fixed64.is_some() {
149            return Some(UnknownValueRef::Fixed64(*fixed64.unwrap()));
150        }
151        let varint = self.varint.next();
152        if varint.is_some() {
153            return Some(UnknownValueRef::Varint(*varint.unwrap()));
154        }
155        let length_delimited = self.length_delimited.next();
156        if length_delimited.is_some() {
157            return Some(UnknownValueRef::LengthDelimited(&length_delimited.unwrap()));
158        }
159        None
160    }
161}
162
163/// Hold "unknown" fields in parsed message.
164///
165/// Field may be unknown if it they are added in newer version of `.proto`.
166/// Unknown fields are stored in `UnknownFields` structure, so
167/// protobuf message could process messages without losing data.
168///
169/// For example, in this operation: load from DB, modify, store to DB,
170/// even when working with older `.proto` file, new fields won't be lost.
171#[derive(Clone, PartialEq, Eq, Debug, Default)]
172pub struct UnknownFields {
173    /// The map.
174    //
175    // `Option` is needed, because HashMap constructor performs allocation,
176    // and very expensive.
177    //
178    // We use "default hasher" to make iteration order deterministic.
179    // Which is used to make codegen output deterministic in presence of unknown fields
180    // (e. g. file options are represented as unknown fields).
181    // Using default hasher is suboptimal, because it makes unknown fields less safe.
182    // Note, Google Protobuf C++ simply uses linear map (which can exploitable the same way),
183    // and Google Protobuf Java uses tree map to store unknown fields
184    // (which is more expensive than hashmap).
185    // TODO: hide
186    pub fields: Option<Box<HashMap<u32, UnknownValues, BuildHasherDefault<DefaultHasher>>>>,
187}
188
189/// Very simple hash implementation of `Hash` for `UnknownFields`.
190/// Since map is unordered, we cannot put entry hashes into hasher,
191/// instead we summing hashes of entries.
192impl Hash for UnknownFields {
193    fn hash<H: Hasher>(&self, state: &mut H) {
194        if let Some(ref map) = self.fields {
195            if !map.is_empty() {
196                let mut hash: u64 = 0;
197                for (k, v) in &**map {
198                    let mut entry_hasher = DefaultHasher::new();
199                    Hash::hash(&(k, v), &mut entry_hasher);
200                    hash = hash.wrapping_add(entry_hasher.finish());
201                }
202                Hash::hash(&map.len(), state);
203                Hash::hash(&hash, state);
204            }
205        }
206    }
207}
208
209impl UnknownFields {
210    /// Empty unknown fields
211    pub fn new() -> UnknownFields {
212        Default::default()
213    }
214
215    fn init_map(&mut self) {
216        if self.fields.is_none() {
217            self.fields = Some(Default::default());
218        }
219    }
220
221    fn find_field<'a>(&'a mut self, number: &'a u32) -> &'a mut UnknownValues {
222        self.init_map();
223
224        match self.fields.as_mut().unwrap().entry(*number) {
225            hash_map::Entry::Occupied(e) => e.into_mut(),
226            hash_map::Entry::Vacant(e) => e.insert(Default::default()),
227        }
228    }
229
230    /// Add unknown fixed 32-bit
231    pub fn add_fixed32(&mut self, number: u32, fixed32: u32) {
232        self.find_field(&number).fixed32.push(fixed32);
233    }
234
235    /// Add unknown fixed 64-bit
236    pub fn add_fixed64(&mut self, number: u32, fixed64: u64) {
237        self.find_field(&number).fixed64.push(fixed64);
238    }
239
240    /// Add unknown varint
241    pub fn add_varint(&mut self, number: u32, varint: u64) {
242        self.find_field(&number).varint.push(varint);
243    }
244
245    /// Add unknown length delimited
246    pub fn add_length_delimited(&mut self, number: u32, length_delimited: Vec<u8>) {
247        self.find_field(&number)
248            .length_delimited
249            .push(length_delimited);
250    }
251
252    /// Add unknown value
253    pub fn add_value(&mut self, number: u32, value: UnknownValue) {
254        self.find_field(&number).add_value(value);
255    }
256
257    /// Remove unknown field by number
258    pub fn remove(&mut self, field_number: u32) {
259        if let Some(fields) = &mut self.fields {
260            fields.remove(&field_number);
261        }
262    }
263
264    /// Iterate over all unknowns
265    pub fn iter<'s>(&'s self) -> UnknownFieldsIter<'s> {
266        UnknownFieldsIter {
267            entries: self.fields.as_ref().map(|m| m.iter()),
268        }
269    }
270
271    /// Find unknown field by number
272    pub fn get(&self, field_number: u32) -> Option<&UnknownValues> {
273        match self.fields {
274            Some(ref map) => map.get(&field_number),
275            None => None,
276        }
277    }
278}
279
280impl Clear for UnknownFields {
281    fn clear(&mut self) {
282        if let Some(ref mut fields) = self.fields {
283            fields.clear();
284        }
285    }
286}
287
288impl<'a> IntoIterator for &'a UnknownFields {
289    type Item = (u32, &'a UnknownValues);
290    type IntoIter = UnknownFieldsIter<'a>;
291
292    fn into_iter(self) -> UnknownFieldsIter<'a> {
293        self.iter()
294    }
295}
296
297/// Iterator over [`UnknownFields`](crate::UnknownFields)
298pub struct UnknownFieldsIter<'s> {
299    entries: Option<hash_map::Iter<'s, u32, UnknownValues>>,
300}
301
302impl<'s> Iterator for UnknownFieldsIter<'s> {
303    type Item = (u32, &'s UnknownValues);
304
305    fn next(&mut self) -> Option<(u32, &'s UnknownValues)> {
306        match self.entries {
307            Some(ref mut entries) => entries.next().map(|(&number, values)| (number, values)),
308            None => None,
309        }
310    }
311}
312
313#[cfg(test)]
314mod test {
315    use std::collections::hash_map::DefaultHasher;
316    use std::hash::Hash;
317    use std::hash::Hasher;
318
319    use super::UnknownFields;
320
321    #[test]
322    fn unknown_fields_hash() {
323        let mut unknown_fields_1 = UnknownFields::new();
324        let mut unknown_fields_2 = UnknownFields::new();
325
326        // Check field order is not important
327
328        unknown_fields_1.add_fixed32(10, 222);
329        unknown_fields_1.add_fixed32(10, 223);
330        unknown_fields_1.add_fixed64(14, 224);
331
332        unknown_fields_2.add_fixed32(10, 222);
333        unknown_fields_2.add_fixed64(14, 224);
334        unknown_fields_2.add_fixed32(10, 223);
335
336        fn hash(unknown_fields: &UnknownFields) -> u64 {
337            let mut hasher = DefaultHasher::new();
338            Hash::hash(unknown_fields, &mut hasher);
339            hasher.finish()
340        }
341
342        assert_eq!(hash(&unknown_fields_1), hash(&unknown_fields_2));
343    }
344
345    #[test]
346    fn unknown_fields_iteration_order_deterministic() {
347        let mut u_1 = UnknownFields::new();
348        let mut u_2 = UnknownFields::new();
349        for u in &mut [&mut u_1, &mut u_2] {
350            u.add_fixed32(10, 20);
351            u.add_varint(30, 40);
352            u.add_fixed64(50, 60);
353            u.add_length_delimited(70, Vec::new());
354            u.add_varint(80, 90);
355            u.add_fixed32(11, 22);
356            u.add_fixed64(33, 44);
357        }
358
359        let items_1: Vec<_> = u_1.iter().collect();
360        let items_2: Vec<_> = u_2.iter().collect();
361        assert_eq!(items_1, items_2);
362    }
363}
protobuf/unknown.rs

protobuf/
unknown.rs
