First test for dynamic messages

Author: stepancheg

protobuf-test/src/common/v2/test_dynamic.rs

@@ -0,0 +1,31 @@
+use protobuf::reflect::FileDescriptor;
+use protobuf::reflect::ReflectValueRef;
+
+use super::test_dynamic_pb;
+
+fn do_test(file_descriptor: &FileDescriptor) {
+    let m = file_descriptor
+        .get_message_by_package_relative_name("ForDynamicTest")
+        .unwrap();
+    let f = m.get_field_by_name("ff").unwrap();
+
+    let mut m = m.new_instance();
+    let m = &mut *m;
+    assert_eq!(None, f.get_singular(m));
+
+    f.set_singular_field(m, 10u32.into());
+    assert_eq!(Some(ReflectValueRef::from(10u32)), f.get_singular(m));
+}
+
+#[test]
+fn test_generated() {
+    do_test(&test_dynamic_pb::file_descriptor());
+}
+
+#[test]
+fn test_dynamic() {
+    do_test(&FileDescriptor::new_dynamic(
+        test_dynamic_pb::file_descriptor().get_proto().clone(),
+        Vec::new(),
+    ));
+}

protobuf-test/src/common/v2/test_dynamic_pb.proto

@@ -0,0 +1,5 @@
+syntax = "proto2";
+
+message ForDynamicTest {
+    optional uint32 ff = 1;
+}

protobuf/src/reflect/dynamic/mod.rs

@@ -10,7 +10,10 @@ use crate::reflect::FieldDescriptor;
 use crate::reflect::MessageDescriptor;
 use crate::reflect::ReflectFieldRef;
 use crate::reflect::ReflectMapMut;
+use crate::reflect::ReflectMapRef;
 use crate::reflect::ReflectRepeatedMut;
+use crate::reflect::ReflectRepeatedRef;
+use crate::reflect::ReflectValueBox;
 use crate::reflect::RuntimeFieldType;
 use crate::Clear;
 use crate::CodedInputStream;
@@ -33,9 +36,9 @@ enum DynamicFieldValue {
 impl DynamicFieldValue {
     fn as_ref(&self) -> ReflectFieldRef {
         match self {
-            DynamicFieldValue::Singular(_v) => unimplemented!(),
-            DynamicFieldValue::Repeated(_r) => unimplemented!(),
-            DynamicFieldValue::Map(_r) => unimplemented!(),
+            DynamicFieldValue::Singular(v) => ReflectFieldRef::Optional(v.get()),
+            DynamicFieldValue::Repeated(r) => ReflectFieldRef::Repeated(ReflectRepeatedRef::new(r)),
+            DynamicFieldValue::Map(m) => ReflectFieldRef::Map(ReflectMapRef::new(m)),
         }
     }
 
@@ -152,6 +155,16 @@ impl DynamicMessage {
         }
     }
 
+    pub(crate) fn set_field(&mut self, field: &FieldDescriptor, value: ReflectValueBox) {
+        assert_eq!(field.message_descriptor, self.descriptor);
+        self.init_fields();
+        // TODO: reset oneof group fields
+        match &mut self.fields[field.index] {
+            DynamicFieldValue::Singular(s) => s.set(value),
+            _ => panic!("Not a singular field: {}", field),
+        }
+    }
+
     pub fn downcast_ref(message: &dyn MessageDyn) -> &DynamicMessage {
         MessageDyn::downcast_ref(message).unwrap()
     }

protobuf/src/reflect/dynamic/optional.rs

@@ -1,5 +1,7 @@
 use crate::reflect::value::value_ref::ReflectValueMut;
-use crate::reflect::{ReflectValueBox, RuntimeTypeBox};
+use crate::reflect::ReflectValueBox;
+use crate::reflect::ReflectValueRef;
+use crate::reflect::RuntimeTypeBox;
 
 #[derive(Debug, Clone)]
 pub(crate) struct DynamicOptional {
@@ -22,4 +24,13 @@ impl DynamicOptional {
     pub fn clear(&mut self) {
         self.value = None;
     }
+
+    pub fn get(&self) -> Option<ReflectValueRef> {
+        self.value.as_ref().map(ReflectValueBox::as_value_ref)
+    }
+
+    pub fn set(&mut self, value: ReflectValueBox) {
+        assert_eq!(value.get_type(), self.elem);
+        self.value = Some(value);
+    }
 }

protobuf/src/reflect/field/dynamic.rs

@@ -4,6 +4,7 @@ use crate::reflect::FieldDescriptor;
 use crate::reflect::ReflectFieldRef;
 use crate::reflect::ReflectMapMut;
 use crate::reflect::ReflectRepeatedMut;
+use crate::reflect::ReflectValueBox;
 
 pub(crate) struct DynamicFieldDescriptorRef<'a> {
     pub(crate) field: &'a FieldDescriptor,
@@ -24,4 +25,8 @@ impl<'a> DynamicFieldDescriptorRef<'a> {
     pub(crate) fn mut_map<'b>(&self, message: &'b mut dyn MessageDyn) -> ReflectMapMut<'b> {
         DynamicMessage::downcast_mut(message).mut_map(&self.field)
     }
+
+    pub(crate) fn set_field(&self, message: &mut dyn MessageDyn, value: ReflectValueBox) {
+        DynamicMessage::downcast_mut(message).set_field(&self.field, value)
+    }
 }

protobuf/src/reflect/field/mod.rs

@@ -321,7 +321,7 @@ impl FieldDescriptor {
     pub fn set_singular_field(&self, m: &mut dyn MessageDyn, value: ReflectValueBox) {
         match self.singular() {
             SingularFieldAccessorRef::Generated(g) => g.accessor.set_field(m, value),
-            SingularFieldAccessorRef::Dynamic(..) => unimplemented!(), // TODO
+            SingularFieldAccessorRef::Dynamic(d) => d.set_field(m, value),
         }
     }
 
@@ -342,7 +342,14 @@ impl FieldDescriptor {
         }
     }
 
-    fn get_singular<'a>(&self, m: &'a dyn MessageDyn) -> Option<ReflectValueRef<'a>> {
+    /// Get singular field value.
+    ///
+    /// Return `None` if field is unset.
+    ///
+    /// # Panics
+    ///
+    /// If this field belongs to a different message type or fields is not singular.
+    pub fn get_singular<'a>(&self, m: &'a dyn MessageDyn) -> Option<ReflectValueRef<'a>> {
         match self.get_reflect(m) {
             ReflectFieldRef::Optional(o) => o,
             _ => panic!("not a singular field"),

protobuf/src/reflect/value/value_ref.rs

@@ -267,3 +267,57 @@ impl<'a> From<EnumValueDescriptor> for ReflectValueRef<'a> {
         ReflectValueRef::Enum(v.enum_descriptor, number)
     }
 }
+
+impl From<u32> for ReflectValueRef<'_> {
+    fn from(v: u32) -> Self {
+        ReflectValueRef::U32(v)
+    }
+}
+
+impl From<i32> for ReflectValueRef<'_> {
+    fn from(v: i32) -> Self {
+        ReflectValueRef::I32(v)
+    }
+}
+
+impl From<u64> for ReflectValueRef<'_> {
+    fn from(v: u64) -> Self {
+        ReflectValueRef::U64(v)
+    }
+}
+
+impl From<i64> for ReflectValueRef<'_> {
+    fn from(v: i64) -> Self {
+        ReflectValueRef::I64(v)
+    }
+}
+
+impl From<f32> for ReflectValueRef<'_> {
+    fn from(v: f32) -> Self {
+        ReflectValueRef::F32(v)
+    }
+}
+
+impl From<f64> for ReflectValueRef<'_> {
+    fn from(v: f64) -> Self {
+        ReflectValueRef::F64(v)
+    }
+}
+
+impl From<bool> for ReflectValueRef<'_> {
+    fn from(v: bool) -> Self {
+        ReflectValueRef::Bool(v)
+    }
+}
+
+impl<'a> From<&'a str> for ReflectValueRef<'a> {
+    fn from(v: &'a str) -> Self {
+        ReflectValueRef::String(v)
+    }
+}
+
+impl<'a> From<&'a [u8]> for ReflectValueRef<'a> {
+    fn from(v: &'a [u8]) -> Self {
+        ReflectValueRef::Bytes(v)
+    }
+}