protobuf/reflect/dynamic/
mod.rs

Help
1use std::any::Any;
2use std::any::TypeId;
3use std::fmt;
4
5use crate::descriptor::field_descriptor_proto::Type;
6use crate::message_dyn::MessageDyn;
7use crate::reflect::dynamic::map::DynamicMap;
8use crate::reflect::dynamic::optional::DynamicOptional;
9use crate::reflect::dynamic::repeated::DynamicRepeated;
10use crate::reflect::map::ReflectMap;
11use crate::reflect::protobuf_type_box::ProtobufType;
12use crate::reflect::repeated::ReflectRepeated;
13use crate::reflect::value::value_ref::ReflectValueMut;
14use crate::reflect::FieldDescriptor;
15use crate::reflect::MessageDescriptor;
16use crate::reflect::ReflectFieldRef;
17use crate::reflect::ReflectMapMut;
18use crate::reflect::ReflectMapRef;
19use crate::reflect::ReflectRepeatedMut;
20use crate::reflect::ReflectRepeatedRef;
21use crate::reflect::ReflectValueBox;
22use crate::reflect::ReflectValueRef;
23use crate::reflect::RuntimeFieldType;
24use crate::reflect::Syntax;
25use crate::rt::bytes_size;
26use crate::rt::compute_raw_varint32_size;
27use crate::rt::compute_raw_varint64_size;
28use crate::rt::int32_size;
29use crate::rt::int64_size;
30use crate::rt::map::read_map_template;
31use crate::rt::sint32_size;
32use crate::rt::sint64_size;
33use crate::rt::string_size;
34use crate::rt::tag_size;
35use crate::rt::uint32_size;
36use crate::rt::uint64_size;
37use crate::rt::unknown_fields_size;
38use crate::rt::unknown_or_group::read_unknown_or_skip_group_with_tag_unpacked;
39use crate::rt::vec_packed_bool_size;
40use crate::rt::vec_packed_double_size;
41use crate::rt::vec_packed_fixed32_size;
42use crate::rt::vec_packed_fixed64_size;
43use crate::rt::vec_packed_float_size;
44use crate::rt::vec_packed_int32_size;
45use crate::rt::vec_packed_int64_size;
46use crate::rt::vec_packed_sfixed32_size;
47use crate::rt::vec_packed_sfixed64_size;
48use crate::rt::vec_packed_sint32_size;
49use crate::rt::vec_packed_sint64_size;
50use crate::rt::vec_packed_uint32_size;
51use crate::rt::vec_packed_uint64_size;
52use crate::text_format;
53use crate::wire_format::WireType;
54use crate::CodedInputStream;
55use crate::CodedOutputStream;
56use crate::SpecialFields;
57use crate::UnknownFields;
58
59pub(crate) mod map;
60pub(crate) mod optional;
61pub(crate) mod repeated;
62
63#[derive(Debug, Clone)]
64enum DynamicFieldValue {
65    Singular(DynamicOptional),
66    Repeated(DynamicRepeated),
67    Map(DynamicMap),
68}
69
70impl DynamicFieldValue {
71    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
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
88impl DynamicFieldValue {
89    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)]
99pub(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
107impl DynamicMessage {
108    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
116    pub(crate) fn descriptor(&self) -> &MessageDescriptor {
117        &self.descriptor
118    }
119
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
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
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
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
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
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
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
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
211    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
216    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
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
273trait ForEachSingularFieldToWrite {
274    fn field(&mut self, t: Type, number: u32, value: &ReflectValueRef) -> crate::Result<()>;
275    fn repeated_packed(
276        &mut self,
277        t: Type,
278        number: u32,
279        value: &ReflectRepeatedRef,
280    ) -> 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<()>;
289    fn unknown_fields(&mut self, unknown_fields: &UnknownFields) -> crate::Result<()>;
290}
291
292impl fmt::Display for DynamicMessage {
293    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
294        text_format::fmt(self, f)
295    }
296}
297
298impl MessageDyn for DynamicMessage {
299    fn descriptor_dyn(&self) -> MessageDescriptor {
300        self.descriptor.clone()
301    }
302
303    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
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
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
443    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
498    fn special_fields_dyn(&self) -> &SpecialFields {
499        &self.special_fields
500    }
501
502    fn mut_special_fields_dyn(&mut self) -> &mut SpecialFields {
503        &mut self.special_fields
504    }
505}
506
507/// Write singular field to output stream
508fn 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
545fn 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
601fn 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
628fn 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
656fn 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}
protobuf/reflect/dynamic/mod.rs

protobuf/reflect/dynamic/
mod.rs
