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