1 use std::any::Any;
2 use std::any::TypeId;
3 use std::fmt;
4 
5 use crate::descriptor::field_descriptor_proto::Type;
6 use crate::message_dyn::MessageDyn;
7 use crate::reflect::dynamic::map::DynamicMap;
8 use crate::reflect::dynamic::optional::DynamicOptional;
9 use crate::reflect::dynamic::repeated::DynamicRepeated;
10 use crate::reflect::map::ReflectMap;
11 use crate::reflect::protobuf_type_box::ProtobufType;
12 use crate::reflect::repeated::ReflectRepeated;
13 use crate::reflect::value::value_ref::ReflectValueMut;
14 use crate::reflect::FieldDescriptor;
15 use crate::reflect::MessageDescriptor;
16 use crate::reflect::ReflectFieldRef;
17 use crate::reflect::ReflectMapMut;
18 use crate::reflect::ReflectMapRef;
19 use crate::reflect::ReflectRepeatedMut;
20 use crate::reflect::ReflectRepeatedRef;
21 use crate::reflect::ReflectValueBox;
22 use crate::reflect::ReflectValueRef;
23 use crate::reflect::RuntimeFieldType;
24 use crate::reflect::Syntax;
25 use crate::rt::bytes_size;
26 use crate::rt::compute_raw_varint32_size;
27 use crate::rt::compute_raw_varint64_size;
28 use crate::rt::int32_size;
29 use crate::rt::int64_size;
30 use crate::rt::map::read_map_template;
31 use crate::rt::sint32_size;
32 use crate::rt::sint64_size;
33 use crate::rt::string_size;
34 use crate::rt::tag_size;
35 use crate::rt::uint32_size;
36 use crate::rt::uint64_size;
37 use crate::rt::unknown_fields_size;
38 use crate::rt::unknown_or_group::read_unknown_or_skip_group_with_tag_unpacked;
39 use crate::rt::vec_packed_bool_size;
40 use crate::rt::vec_packed_double_size;
41 use crate::rt::vec_packed_fixed32_size;
42 use crate::rt::vec_packed_fixed64_size;
43 use crate::rt::vec_packed_float_size;
44 use crate::rt::vec_packed_int32_size;
45 use crate::rt::vec_packed_int64_size;
46 use crate::rt::vec_packed_sfixed32_size;
47 use crate::rt::vec_packed_sfixed64_size;
48 use crate::rt::vec_packed_sint32_size;
49 use crate::rt::vec_packed_sint64_size;
50 use crate::rt::vec_packed_uint32_size;
51 use crate::rt::vec_packed_uint64_size;
52 use crate::text_format;
53 use crate::wire_format::WireType;
54 use crate::CodedInputStream;
55 use crate::CodedOutputStream;
56 use crate::SpecialFields;
57 use crate::UnknownFields;
58 
59 pub(crate) mod map;
60 pub(crate) mod optional;
61 pub(crate) mod repeated;
62 
63 #[derive(Debug, Clone)]
64 enum DynamicFieldValue {
65     Singular(DynamicOptional),
66     Repeated(DynamicRepeated),
67     Map(DynamicMap),
68 }
69 
70 impl DynamicFieldValue {
as_ref(&self) -> ReflectFieldRef71     fn as_ref(&self) -> ReflectFieldRef {
72         match self {
73             DynamicFieldValue::Singular(v) => ReflectFieldRef::Optional(v.reflect_singlar_ref()),
74             DynamicFieldValue::Repeated(r) => ReflectFieldRef::Repeated(ReflectRepeatedRef::new(r)),
75             DynamicFieldValue::Map(m) => ReflectFieldRef::Map(ReflectMapRef::new(m)),
76         }
77     }
78 
clear(&mut self)79     fn clear(&mut self) {
80         match self {
81             DynamicFieldValue::Singular(o) => o.clear(),
82             DynamicFieldValue::Repeated(r) => r.clear(),
83             DynamicFieldValue::Map(m) => m.clear(),
84         }
85     }
86 }
87 
88 impl DynamicFieldValue {
default_for_field(field: &FieldDescriptor) -> DynamicFieldValue89     fn default_for_field(field: &FieldDescriptor) -> DynamicFieldValue {
90         match field.runtime_field_type() {
91             RuntimeFieldType::Singular(s) => DynamicFieldValue::Singular(DynamicOptional::none(s)),
92             RuntimeFieldType::Repeated(r) => DynamicFieldValue::Repeated(DynamicRepeated::new(r)),
93             RuntimeFieldType::Map(k, v) => DynamicFieldValue::Map(DynamicMap::new(k, v)),
94         }
95     }
96 }
97 
98 #[derive(Debug, Clone)]
99 pub(crate) struct DynamicMessage {
100     descriptor: MessageDescriptor,
101     /// Fields by index in the description.
102     /// This field is lazy-init: it is empty when created.
103     fields: Box<[DynamicFieldValue]>,
104     special_fields: SpecialFields,
105 }
106 
107 impl DynamicMessage {
new(descriptor: MessageDescriptor) -> DynamicMessage108     pub(crate) fn new(descriptor: MessageDescriptor) -> DynamicMessage {
109         DynamicMessage {
110             descriptor,
111             fields: Vec::new().into_boxed_slice(),
112             special_fields: SpecialFields::new(),
113         }
114     }
115 
descriptor(&self) -> &MessageDescriptor116     pub(crate) fn descriptor(&self) -> &MessageDescriptor {
117         &self.descriptor
118     }
119 
init_fields(&mut self)120     fn init_fields(&mut self) {
121         if self.fields.is_empty() {
122             self.fields = self
123                 .descriptor
124                 .fields()
125                 .map(|f| DynamicFieldValue::default_for_field(&f))
126                 .collect();
127         }
128     }
129 
get_reflect<'a>(&'a self, field: &FieldDescriptor) -> ReflectFieldRef<'a>130     pub(crate) fn get_reflect<'a>(&'a self, field: &FieldDescriptor) -> ReflectFieldRef<'a> {
131         let (descriptor, index) = field.regular();
132         assert_eq!(self.descriptor, descriptor);
133         if self.fields.is_empty() {
134             ReflectFieldRef::default_for_field(field)
135         } else {
136             self.fields[index].as_ref()
137         }
138     }
139 
clear_field(&mut self, field: &FieldDescriptor)140     pub fn clear_field(&mut self, field: &FieldDescriptor) {
141         let (descriptor, index) = field.regular();
142         assert_eq!(self.descriptor, descriptor);
143         if self.fields.is_empty() {
144             return;
145         }
146 
147         self.fields[index].clear();
148     }
149 
clear_oneof_group_fields_except(&mut self, field: &FieldDescriptor)150     fn clear_oneof_group_fields_except(&mut self, field: &FieldDescriptor) {
151         if let Some(oneof) = field.containing_oneof_including_synthetic() {
152             for next in oneof.fields() {
153                 if &next == field {
154                     continue;
155                 }
156                 self.clear_field(&next);
157             }
158         }
159     }
160 
mut_singular_field_or_default<'a>( &'a mut self, field: &FieldDescriptor, ) -> ReflectValueMut<'a>161     pub(crate) fn mut_singular_field_or_default<'a>(
162         &'a mut self,
163         field: &FieldDescriptor,
164     ) -> ReflectValueMut<'a> {
165         let (descriptor, index) = field.regular();
166         assert_eq!(self.descriptor, descriptor);
167         self.init_fields();
168         self.clear_oneof_group_fields_except(field);
169         match &mut self.fields[index] {
170             DynamicFieldValue::Singular(f) => f.mut_or_default(),
171             _ => panic!("Not a singular field"),
172         }
173     }
174 
mut_repeated<'a>( &'a mut self, field: &FieldDescriptor, ) -> ReflectRepeatedMut<'a>175     pub(crate) fn mut_repeated<'a>(
176         &'a mut self,
177         field: &FieldDescriptor,
178     ) -> ReflectRepeatedMut<'a> {
179         let (descriptor, index) = field.regular();
180         assert_eq!(self.descriptor, descriptor);
181         self.init_fields();
182         self.clear_oneof_group_fields_except(field);
183         match &mut self.fields[index] {
184             DynamicFieldValue::Repeated(r) => ReflectRepeatedMut::new(r),
185             _ => panic!("Not a repeated field: {}", field),
186         }
187     }
188 
mut_map<'a>(&'a mut self, field: &FieldDescriptor) -> ReflectMapMut<'a>189     pub(crate) fn mut_map<'a>(&'a mut self, field: &FieldDescriptor) -> ReflectMapMut<'a> {
190         let (descriptor, index) = field.regular();
191         assert_eq!(self.descriptor, descriptor);
192         self.init_fields();
193         self.clear_oneof_group_fields_except(field);
194         match &mut self.fields[index] {
195             DynamicFieldValue::Map(m) => ReflectMapMut::new(m),
196             _ => panic!("Not a map field: {}", field),
197         }
198     }
199 
set_field(&mut self, field: &FieldDescriptor, value: ReflectValueBox)200     pub(crate) fn set_field(&mut self, field: &FieldDescriptor, value: ReflectValueBox) {
201         let (descriptor, index) = field.regular();
202         assert_eq!(self.descriptor, descriptor);
203         self.init_fields();
204         self.clear_oneof_group_fields_except(field);
205         match &mut self.fields[index] {
206             DynamicFieldValue::Singular(s) => s.set(value),
207             _ => panic!("Not a singular field: {}", field),
208         }
209     }
210 
downcast_ref(message: &dyn MessageDyn) -> &DynamicMessage211     pub(crate) fn downcast_ref(message: &dyn MessageDyn) -> &DynamicMessage {
212         assert!(Any::type_id(&*message) == TypeId::of::<DynamicMessage>());
213         unsafe { &*(message as *const dyn MessageDyn as *const DynamicMessage) }
214     }
215 
downcast_mut(message: &mut dyn MessageDyn) -> &mut DynamicMessage216     pub(crate) fn downcast_mut(message: &mut dyn MessageDyn) -> &mut DynamicMessage {
217         assert!(Any::type_id(&*message) == TypeId::of::<DynamicMessage>());
218         unsafe { &mut *(message as *mut dyn MessageDyn as *mut DynamicMessage) }
219     }
220 
for_each_field_to_write( &self, handler: &mut impl ForEachSingularFieldToWrite, ) -> crate::Result<()>221     fn for_each_field_to_write(
222         &self,
223         handler: &mut impl ForEachSingularFieldToWrite,
224     ) -> crate::Result<()> {
225         let is_proto3 = self.descriptor.file_descriptor().syntax() == Syntax::Proto3;
226         for field_desc in self.descriptor.fields() {
227             let field_number = field_desc.proto().number() as u32;
228             match field_desc.runtime_field_type() {
229                 RuntimeFieldType::Singular(..) => {
230                     if let Some(v) = field_desc.get_singular(self) {
231                         // Ignore default value for proto3.
232                         if !is_proto3 || v.is_non_zero() {
233                             handler.field(field_desc.proto().type_(), field_number, &v)?;
234                         }
235                     }
236                 }
237                 RuntimeFieldType::Repeated(..) => {
238                     let repeated = field_desc.get_repeated(self);
239                     if field_desc.proto().options.get_or_default().packed() {
240                         handler.repeated_packed(
241                             field_desc.proto().type_(),
242                             field_number,
243                             &repeated,
244                         )?;
245                     } else {
246                         for i in 0..repeated.len() {
247                             let v = repeated.get(i);
248                             handler.field(field_desc.proto().type_(), field_number, &v)?;
249                         }
250                     }
251                 }
252                 RuntimeFieldType::Map(_, _) => {
253                     let map = field_desc.get_map(self);
254                     let (key_type, value_type) = field_desc.map_proto_type();
255                     for (k, v) in &map {
256                         handler.map_field_entry(
257                             field_number,
258                             &k,
259                             key_type.t(),
260                             &v,
261                             value_type.t(),
262                         )?;
263                     }
264                 }
265             }
266         }
267 
268         handler.unknown_fields(&self.special_fields.unknown_fields())?;
269         Ok(())
270     }
271 }
272 
273 trait ForEachSingularFieldToWrite {
field(&mut self, t: Type, number: u32, value: &ReflectValueRef) -> crate::Result<()>274     fn field(&mut self, t: Type, number: u32, value: &ReflectValueRef) -> crate::Result<()>;
repeated_packed( &mut self, t: Type, number: u32, value: &ReflectRepeatedRef, ) -> crate::Result<()>275     fn repeated_packed(
276         &mut self,
277         t: Type,
278         number: u32,
279         value: &ReflectRepeatedRef,
280     ) -> crate::Result<()>;
map_field_entry( &mut self, number: u32, key: &ReflectValueRef, kt: Type, value: &ReflectValueRef, vt: Type, ) -> crate::Result<()>281     fn map_field_entry(
282         &mut self,
283         number: u32,
284         key: &ReflectValueRef,
285         kt: Type,
286         value: &ReflectValueRef,
287         vt: Type,
288     ) -> crate::Result<()>;
unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()>289     fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()>;
290 }
291 
292 impl fmt::Display for DynamicMessage {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result293     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
294         text_format::fmt(self, f)
295     }
296 }
297 
298 impl MessageDyn for DynamicMessage {
descriptor_dyn(&self) -> MessageDescriptor299     fn descriptor_dyn(&self) -> MessageDescriptor {
300         self.descriptor.clone()
301     }
302 
is_initialized_dyn(&self) -> bool303     fn is_initialized_dyn(&self) -> bool {
304         if self.descriptor.is_initialized_is_always_true() {
305             return true;
306         }
307 
308         for f in self.descriptor.fields() {
309             let fv = self.get_reflect(&f);
310             match fv {
311                 ReflectFieldRef::Optional(s) => match s.value() {
312                     None => {
313                         if f.is_required() {
314                             return false;
315                         }
316                     }
317                     Some(v) => {
318                         if !v.is_initialized() {
319                             return false;
320                         }
321                     }
322                 },
323                 ReflectFieldRef::Repeated(r) => {
324                     for v in &r {
325                         if !v.is_initialized() {
326                             return false;
327                         }
328                     }
329                 }
330                 ReflectFieldRef::Map(m) => {
331                     for (_k, v) in &m {
332                         // Keys cannot be messages, so only check values.
333                         if !v.is_initialized() {
334                             return false;
335                         }
336                     }
337                 }
338             }
339         }
340         true
341     }
342 
merge_from_dyn(&mut self, is: &mut CodedInputStream) -> crate::Result<()>343     fn merge_from_dyn(&mut self, is: &mut CodedInputStream) -> crate::Result<()> {
344         while !is.eof()? {
345             let (field, wire_type) = is.read_tag_unpack()?;
346             let field_desc = match self.descriptor.field_by_number(field) {
347                 Some(f) => f,
348                 None => {
349                     read_unknown_or_skip_group_with_tag_unpacked(
350                         field,
351                         wire_type,
352                         is,
353                         &mut self.special_fields.mut_unknown_fields(),
354                     )?;
355                     continue;
356                 }
357             };
358             match field_desc.runtime_field_type() {
359                 RuntimeFieldType::Singular(rtb) => {
360                     let pt = ProtobufType::new(rtb, field_desc.proto().type_())?;
361                     let value = pt.read(is, wire_type)?;
362                     self.set_field(&field_desc, value);
363                 }
364                 RuntimeFieldType::Repeated(rtb) => {
365                     let pt = ProtobufType::new(rtb, field_desc.proto().type_())?;
366                     let mut repeated = self.mut_repeated(&field_desc);
367                     pt.read_repeated_into(is, wire_type, &mut repeated)?;
368                 }
369                 RuntimeFieldType::Map(..) => {
370                     let (key_type, value_type) = field_desc.map_proto_type();
371                     let mut map = self.mut_map(&field_desc);
372                     let mut key = key_type.runtime().default_value_box();
373                     let mut value = value_type.runtime().default_value_box();
374                     read_map_template(
375                         wire_type,
376                         is,
377                         |wire_type, is| {
378                             key = key_type.read(is, wire_type)?;
379                             Ok(())
380                         },
381                         |wire_type, is| {
382                             value = value_type.read(is, wire_type)?;
383                             Ok(())
384                         },
385                     )?;
386                     map.insert(key, value);
387                 }
388             }
389         }
390         Ok(())
391     }
392 
write_to_with_cached_sizes_dyn(&self, os: &mut CodedOutputStream) -> crate::Result<()>393     fn write_to_with_cached_sizes_dyn(&self, os: &mut CodedOutputStream) -> crate::Result<()> {
394         struct Handler<'a, 'o> {
395             os: &'a mut CodedOutputStream<'o>,
396         }
397 
398         impl<'a, 'o> ForEachSingularFieldToWrite for Handler<'a, 'o> {
399             fn field(
400                 &mut self,
401                 t: Type,
402                 number: u32,
403                 value: &ReflectValueRef,
404             ) -> crate::Result<()> {
405                 singular_write_to(t, number, value, self.os)
406             }
407 
408             fn repeated_packed(
409                 &mut self,
410                 t: Type,
411                 number: u32,
412                 value: &ReflectRepeatedRef,
413             ) -> crate::Result<()> {
414                 repeated_write_to(t, number, value, self.os)
415             }
416 
417             fn map_field_entry(
418                 &mut self,
419                 number: u32,
420                 key: &ReflectValueRef,
421                 kt: Type,
422                 value: &ReflectValueRef,
423                 vt: Type,
424             ) -> crate::Result<()> {
425                 let entry_data_size = compute_map_entry_field_data_size(key, kt, value, vt);
426                 self.os.write_tag(number, WireType::LengthDelimited)?;
427                 self.os.write_raw_varint32(entry_data_size as u32)?;
428                 singular_write_to(kt, 1, key, self.os)?;
429                 singular_write_to(vt, 2, value, self.os)?;
430                 Ok(())
431             }
432 
433             fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()> {
434                 self.os.write_unknown_fields(unknown_fields)
435             }
436         }
437 
438         let mut handler = Handler { os };
439 
440         self.for_each_field_to_write(&mut handler)
441     }
442 
compute_size_dyn(&self) -> u64443     fn compute_size_dyn(&self) -> u64 {
444         struct Handler {
445             m_size: u64,
446         }
447 
448         impl ForEachSingularFieldToWrite for Handler {
449             fn field(
450                 &mut self,
451                 t: Type,
452                 number: u32,
453                 value: &ReflectValueRef,
454             ) -> crate::Result<()> {
455                 self.m_size += compute_singular_size(t, number, value);
456                 Ok(())
457             }
458 
459             fn repeated_packed(
460                 &mut self,
461                 t: Type,
462                 number: u32,
463                 value: &ReflectRepeatedRef,
464             ) -> crate::Result<()> {
465                 self.m_size += compute_repeated_packed_size(t, number, value);
466                 Ok(())
467             }
468 
469             fn map_field_entry(
470                 &mut self,
471                 number: u32,
472                 key: &ReflectValueRef,
473                 kt: Type,
474                 value: &ReflectValueRef,
475                 vt: Type,
476             ) -> crate::Result<()> {
477                 let entry_data_size = compute_map_entry_field_data_size(key, kt, value, vt);
478                 self.m_size += tag_size(number)
479                     + compute_raw_varint32_size(entry_data_size as u32)
480                     + entry_data_size;
481                 Ok(())
482             }
483 
484             fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()> {
485                 self.m_size += unknown_fields_size(unknown_fields);
486                 Ok(())
487             }
488         }
489 
490         let mut handler = Handler { m_size: 0 };
491 
492         self.for_each_field_to_write(&mut handler)
493             .expect("compute_size should not fail");
494 
495         handler.m_size
496     }
497 
special_fields_dyn(&self) -> &SpecialFields498     fn special_fields_dyn(&self) -> &SpecialFields {
499         &self.special_fields
500     }
501 
mut_special_fields_dyn(&mut self) -> &mut SpecialFields502     fn mut_special_fields_dyn(&mut self) -> &mut SpecialFields {
503         &mut self.special_fields
504     }
505 }
506 
507 /// Write singular field to output stream
singular_write_to( proto_type: Type, field_number: u32, v: &ReflectValueRef, os: &mut CodedOutputStream, ) -> crate::Result<()>508 fn singular_write_to(
509     proto_type: Type,
510     field_number: u32,
511     v: &ReflectValueRef,
512     os: &mut CodedOutputStream,
513 ) -> crate::Result<()> {
514     match proto_type {
515         Type::TYPE_ENUM => {
516             let enum_v = v.to_enum_value().unwrap();
517             os.write_enum(field_number, enum_v)
518         }
519         Type::TYPE_MESSAGE => {
520             let msg_v = v.to_message().unwrap();
521             os.write_message_dyn(field_number, &*msg_v)
522         }
523         Type::TYPE_GROUP => {
524             unimplemented!()
525         }
526         Type::TYPE_UINT32 => os.write_uint32(field_number, v.to_u32().unwrap()),
527         Type::TYPE_UINT64 => os.write_uint64(field_number, v.to_u64().unwrap()),
528         Type::TYPE_INT32 => os.write_int32(field_number, v.to_i32().unwrap()),
529         Type::TYPE_INT64 => os.write_int64(field_number, v.to_i64().unwrap()),
530         Type::TYPE_SINT32 => os.write_sint32(field_number, v.to_i32().unwrap()),
531         Type::TYPE_SINT64 => os.write_sint64(field_number, v.to_i64().unwrap()),
532         Type::TYPE_FIXED32 => os.write_fixed32(field_number, v.to_u32().unwrap()),
533         Type::TYPE_FIXED64 => os.write_fixed64(field_number, v.to_u64().unwrap()),
534         Type::TYPE_SFIXED64 => os.write_sfixed64(field_number, v.to_i64().unwrap()),
535         Type::TYPE_SFIXED32 => os.write_sfixed32(field_number, v.to_i32().unwrap()),
536         Type::TYPE_BOOL => os.write_bool(field_number, v.to_bool().unwrap()),
537         Type::TYPE_STRING => os.write_string(field_number, v.to_str().unwrap()),
538         Type::TYPE_BYTES => os.write_bytes(field_number, v.to_bytes().unwrap()),
539         Type::TYPE_FLOAT => os.write_float(field_number, v.to_f32().unwrap()),
540         Type::TYPE_DOUBLE => os.write_double(field_number, v.to_f64().unwrap()),
541     }
542 }
543 
544 /// Compute singular field size
compute_singular_size(proto_type: Type, field_number: u32, v: &ReflectValueRef) -> u64545 fn compute_singular_size(proto_type: Type, field_number: u32, v: &ReflectValueRef) -> u64 {
546     match proto_type {
547         Type::TYPE_ENUM => {
548             let enum_v = v.to_enum_value().unwrap();
549             int32_size(field_number, enum_v)
550         }
551         Type::TYPE_MESSAGE => {
552             let msg_v = v.to_message().unwrap();
553             let len = msg_v.compute_size_dyn();
554             tag_size(field_number) + compute_raw_varint64_size(len) + len
555         }
556         Type::TYPE_GROUP => {
557             unimplemented!()
558         }
559         Type::TYPE_UINT32 => {
560             let typed_v = v.to_u32().unwrap();
561             uint32_size(field_number, typed_v)
562         }
563         Type::TYPE_UINT64 => {
564             let typed_v = v.to_u64().unwrap();
565             uint64_size(field_number, typed_v)
566         }
567         Type::TYPE_INT32 => {
568             let typed_v = v.to_i32().unwrap();
569             int32_size(field_number, typed_v)
570         }
571         Type::TYPE_INT64 => {
572             let typed_v = v.to_i64().unwrap();
573             int64_size(field_number, typed_v)
574         }
575         Type::TYPE_SINT32 => {
576             let typed_v = v.to_i32().unwrap();
577             sint32_size(field_number, typed_v)
578         }
579         Type::TYPE_SINT64 => {
580             let typed_v = v.to_i64().unwrap();
581             sint64_size(field_number, typed_v)
582         }
583         Type::TYPE_FIXED32 => tag_size(field_number) + 4,
584         Type::TYPE_FIXED64 => tag_size(field_number) + 8,
585         Type::TYPE_SFIXED32 => tag_size(field_number) + 4,
586         Type::TYPE_SFIXED64 => tag_size(field_number) + 8,
587         Type::TYPE_BOOL => tag_size(field_number) + 1,
588         Type::TYPE_STRING => {
589             let typed_v = v.to_str().unwrap();
590             string_size(field_number, typed_v)
591         }
592         Type::TYPE_BYTES => {
593             let typed_v = v.to_bytes().unwrap();
594             bytes_size(field_number, typed_v)
595         }
596         Type::TYPE_FLOAT => tag_size(field_number) + 4,
597         Type::TYPE_DOUBLE => tag_size(field_number) + 8,
598     }
599 }
600 
compute_repeated_packed_size( proto_type: Type, field_number: u32, v: &ReflectRepeatedRef, ) -> u64601 fn compute_repeated_packed_size(
602     proto_type: Type,
603     field_number: u32,
604     v: &ReflectRepeatedRef,
605 ) -> u64 {
606     match proto_type {
607         Type::TYPE_INT32 => vec_packed_int32_size(field_number, v.data_i32()),
608         Type::TYPE_INT64 => vec_packed_int64_size(field_number, v.data_i64()),
609         Type::TYPE_UINT32 => vec_packed_uint32_size(field_number, v.data_u32()),
610         Type::TYPE_UINT64 => vec_packed_uint64_size(field_number, v.data_u64()),
611         Type::TYPE_SINT32 => vec_packed_sint32_size(field_number, v.data_i32()),
612         Type::TYPE_SINT64 => vec_packed_sint64_size(field_number, v.data_i64()),
613         Type::TYPE_FIXED32 => vec_packed_fixed32_size(field_number, v.data_u32()),
614         Type::TYPE_FIXED64 => vec_packed_fixed64_size(field_number, v.data_u64()),
615         Type::TYPE_SFIXED32 => vec_packed_sfixed32_size(field_number, v.data_i32()),
616         Type::TYPE_SFIXED64 => vec_packed_sfixed64_size(field_number, v.data_i64()),
617         Type::TYPE_FLOAT => vec_packed_float_size(field_number, v.data_f32()),
618         Type::TYPE_DOUBLE => vec_packed_double_size(field_number, v.data_f64()),
619         Type::TYPE_BOOL => vec_packed_bool_size(field_number, v.data_bool()),
620         Type::TYPE_STRING => panic!("strings cannot be packed"),
621         Type::TYPE_BYTES => panic!("bytes cannot be packed"),
622         Type::TYPE_ENUM => vec_packed_int32_size(field_number, v.data_enum_values()),
623         Type::TYPE_MESSAGE => panic!("messages cannot be packed"),
624         Type::TYPE_GROUP => panic!("groups cannot be packed"),
625     }
626 }
627 
repeated_write_to( proto_type: Type, field_number: u32, v: &ReflectRepeatedRef, os: &mut CodedOutputStream, ) -> crate::Result<()>628 fn repeated_write_to(
629     proto_type: Type,
630     field_number: u32,
631     v: &ReflectRepeatedRef,
632     os: &mut CodedOutputStream,
633 ) -> crate::Result<()> {
634     match proto_type {
635         Type::TYPE_INT32 => os.write_repeated_packed_int32(field_number, v.data_i32()),
636         Type::TYPE_INT64 => os.write_repeated_packed_int64(field_number, v.data_i64()),
637         Type::TYPE_UINT64 => os.write_repeated_packed_uint64(field_number, v.data_u64()),
638         Type::TYPE_FIXED64 => os.write_repeated_packed_fixed64(field_number, v.data_u64()),
639         Type::TYPE_FIXED32 => os.write_repeated_packed_fixed32(field_number, v.data_u32()),
640         Type::TYPE_UINT32 => os.write_repeated_packed_uint32(field_number, v.data_u32()),
641         Type::TYPE_SINT32 => os.write_repeated_packed_sint32(field_number, v.data_i32()),
642         Type::TYPE_SINT64 => os.write_repeated_packed_sint64(field_number, v.data_i64()),
643         Type::TYPE_SFIXED32 => os.write_repeated_packed_sfixed32(field_number, v.data_i32()),
644         Type::TYPE_SFIXED64 => os.write_repeated_packed_sfixed64(field_number, v.data_i64()),
645         Type::TYPE_BOOL => os.write_repeated_packed_bool(field_number, v.data_bool()),
646         Type::TYPE_FLOAT => os.write_repeated_packed_float(field_number, v.data_f32()),
647         Type::TYPE_DOUBLE => os.write_repeated_packed_double(field_number, v.data_f64()),
648         Type::TYPE_ENUM => os.write_repeated_packed_int32(field_number, v.data_enum_values()),
649         Type::TYPE_STRING => panic!("strings cannot be packed"),
650         Type::TYPE_BYTES => panic!("bytes cannot be packed"),
651         Type::TYPE_GROUP => panic!("groups cannot be packed"),
652         Type::TYPE_MESSAGE => panic!("messages cannot be packed"),
653     }
654 }
655 
compute_map_entry_field_data_size( key: &ReflectValueRef, kt: Type, value: &ReflectValueRef, vt: Type, ) -> u64656 fn compute_map_entry_field_data_size(
657     key: &ReflectValueRef,
658     kt: Type,
659     value: &ReflectValueRef,
660     vt: Type,
661 ) -> u64 {
662     let key_size = compute_singular_size(kt, 1, key);
663     let value_size = compute_singular_size(vt, 2, value);
664     key_size + value_size
665 }
666