Implement iterator for DynamicMap

Author: stepancheg

protobuf/src/reflect/dynamic/map.rs

@@ -1,9 +1,14 @@
-use crate::reflect::map::ReflectMap;
 use crate::reflect::map::ReflectMapIter;
-use crate::reflect::ReflectValueBox;
+use crate::reflect::map::ReflectMap;
+use crate::reflect::map::ReflectMapIterTrait;
+use crate::reflect::runtime_types::RuntimeType;
 use crate::reflect::ReflectValueRef;
 use crate::reflect::RuntimeTypeBox;
+use crate::reflect::ProtobufValue;
+use crate::reflect::ReflectValueBox;
+use std::collections::hash_map;
 use std::collections::HashMap;
+use std::hash::Hash;
 
 #[derive(Debug, Clone)]
 enum Maps {
@@ -84,10 +89,57 @@ impl DynamicMap {
     }
 }
 
+struct DynamicMapIterImpl<'a, K: ProtobufValue + Eq + Hash + 'static> {
+    iter: hash_map::Iter<'a, K, ReflectValueBox>,
+    value: &'a RuntimeTypeBox,
+}
+
+impl<'a, K: ProtobufValue + Eq + Hash + 'static> ReflectMapIterTrait<'a>
+    for DynamicMapIterImpl<'a, K>
+{
+    fn next(&mut self) -> Option<(ReflectValueRef<'a>, ReflectValueRef<'a>)> {
+        self.iter
+            .next()
+            .map(|(k, v)| (K::as_ref(k), v.as_value_ref()))
+    }
+
+    fn key_type(&self) -> RuntimeTypeBox {
+        K::RuntimeType::runtime_type_box()
+    }
+
+    fn value_type(&self) -> RuntimeTypeBox {
+        self.value.clone()
+    }
+}
+
 impl ReflectMap for DynamicMap {
     fn reflect_iter(&self) -> ReflectMapIter {
-        // TODO
-        unimplemented!()
+        match &self.maps {
+            Maps::U32(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+            Maps::I32(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+            Maps::U64(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+            Maps::I64(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+            Maps::Bool(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+            Maps::String(m) => ReflectMapIter::new(DynamicMapIterImpl {
+                iter: m.iter(),
+                value: &self.value,
+            }),
+        }
     }
 
     fn len(&self) -> usize {

protobuf/src/reflect/map/generated.rs

@@ -16,9 +16,7 @@ where
     K::RuntimeType: RuntimeTypeHashable,
 {
     fn reflect_iter<'a>(&'a self) -> ReflectMapIter<'a> {
-        ReflectMapIter {
-            imp: Box::new(GeneratedMapIterImpl::<'a, K, V> { iter: self.iter() }),
-        }
+        ReflectMapIter::new(GeneratedMapIterImpl::<'a, K, V> { iter: self.iter() })
     }
 
     fn len(&self) -> usize {

protobuf/src/reflect/map/mod.rs

@@ -25,7 +25,7 @@ pub(crate) trait ReflectMap: Send + Sync + 'static {
     fn value_type(&self) -> RuntimeTypeBox;
 }
 
-trait ReflectMapIterTrait<'a> {
+pub(crate) trait ReflectMapIterTrait<'a> {
     fn next(&mut self) -> Option<(ReflectValueRef<'a>, ReflectValueRef<'a>)>;
     fn key_type(&self) -> RuntimeTypeBox;
     fn value_type(&self) -> RuntimeTypeBox;
@@ -35,6 +35,12 @@ pub struct ReflectMapIter<'a> {
     imp: Box<dyn ReflectMapIterTrait<'a> + 'a>,
 }
 
+impl<'a> ReflectMapIter<'a> {
+    pub(crate) fn new<I: ReflectMapIterTrait<'a> + 'a>(imp: I) -> ReflectMapIter<'a> {
+        ReflectMapIter { imp: Box::new(imp) }
+    }
+}
+
 impl<'a> Iterator for ReflectMapIter<'a> {
     type Item = (ReflectValueRef<'a>, ReflectValueRef<'a>);