Move generated map support code into a separate file

Author: stepancheg

protobuf/src/reflect/map/generated.rs

@@ -0,0 +1,76 @@
+use crate::reflect::map::ReflectMap;
+use crate::reflect::map::{ReflectMapIter, ReflectMapIterTrait};
+use crate::reflect::runtime_types::RuntimeTypeHashable;
+use crate::reflect::ProtobufValue;
+use crate::reflect::ReflectValueBox;
+use crate::reflect::ReflectValueRef;
+use crate::reflect::RuntimeTypeBox;
+use std::collections::hash_map;
+use std::collections::HashMap;
+use std::hash::Hash;
+
+impl<K, V> ReflectMap for HashMap<K, V>
+where
+    K: ProtobufValue + Eq + Hash,
+    V: ProtobufValue,
+    K::RuntimeType: RuntimeTypeHashable,
+{
+    fn reflect_iter<'a>(&'a self) -> ReflectMapIter<'a> {
+        ReflectMapIter {
+            imp: Box::new(GeneratedMapIterImpl::<'a, K, V> { iter: self.iter() }),
+        }
+    }
+
+    fn len(&self) -> usize {
+        HashMap::len(self)
+    }
+
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
+
+    fn get<'a>(&'a self, key: ReflectValueRef) -> Option<ReflectValueRef<'a>> {
+        <K::RuntimeType as RuntimeTypeHashable>::hash_map_get(self, key).map(V::as_ref)
+    }
+
+    fn insert(&mut self, key: ReflectValueBox, value: ReflectValueBox) {
+        let key: K = key.downcast().expect("wrong key type");
+        let value: V = value.downcast().expect("wrong value type");
+        self.insert(key, value);
+    }
+
+    fn clear(&mut self) {
+        self.clear();
+    }
+
+    fn key_type(&self) -> RuntimeTypeBox {
+        K::runtime_type_box()
+    }
+
+    fn value_type(&self) -> RuntimeTypeBox {
+        V::runtime_type_box()
+    }
+}
+
+struct GeneratedMapIterImpl<'a, K: Eq + Hash + 'static, V: 'static> {
+    iter: hash_map::Iter<'a, K, V>,
+}
+
+impl<'a, K: ProtobufValue + Eq + Hash, V: ProtobufValue> ReflectMapIterTrait<'a>
+    for GeneratedMapIterImpl<'a, K, V>
+{
+    fn next(&mut self) -> Option<(ReflectValueRef<'a>, ReflectValueRef<'a>)> {
+        match self.iter.next() {
+            Some((k, v)) => Some((K::as_ref(k), V::as_ref(v))),
+            None => None,
+        }
+    }
+
+    fn key_type(&self) -> RuntimeTypeBox {
+        K::runtime_type_box()
+    }
+
+    fn value_type(&self) -> RuntimeTypeBox {
+        V::runtime_type_box()
+    }
+}

protobuf/src/reflect/map.rs renamed to protobuf/src/reflect/map/mod.rs

@@ -1,15 +1,11 @@
-use std::collections::hash_map;
-use std::collections::HashMap;
-use std::hash::Hash;
-
 use crate::reflect::reflect_eq::ReflectEq;
 use crate::reflect::reflect_eq::ReflectEqMode;
-use crate::reflect::runtime_types::RuntimeTypeHashable;
-use crate::reflect::ProtobufValue;
 use crate::reflect::ReflectValueBox;
 use crate::reflect::ReflectValueRef;
 use crate::reflect::RuntimeTypeBox;
 
+mod generated;
+
 /// Implemented for `HashMap` with appropriate keys and values
 pub(crate) trait ReflectMap: Send + Sync + 'static {
     fn reflect_iter(&self) -> ReflectMapIter;
@@ -29,78 +25,12 @@ pub(crate) trait ReflectMap: Send + Sync + 'static {
     fn value_type(&self) -> RuntimeTypeBox;
 }
 
-impl<K, V> ReflectMap for HashMap<K, V>
-where
-    K: ProtobufValue + Eq + Hash,
-    V: ProtobufValue,
-    K::RuntimeType: RuntimeTypeHashable,
-{
-    fn reflect_iter<'a>(&'a self) -> ReflectMapIter<'a> {
-        ReflectMapIter {
-            imp: Box::new(ReflectMapIterImpl::<'a, K, V> { iter: self.iter() }),
-        }
-    }
-
-    fn len(&self) -> usize {
-        HashMap::len(self)
-    }
-
-    fn is_empty(&self) -> bool {
-        self.is_empty()
-    }
-
-    fn get<'a>(&'a self, key: ReflectValueRef) -> Option<ReflectValueRef<'a>> {
-        <K::RuntimeType as RuntimeTypeHashable>::hash_map_get(self, key).map(V::as_ref)
-    }
-
-    fn insert(&mut self, key: ReflectValueBox, value: ReflectValueBox) {
-        let key: K = key.downcast().expect("wrong key type");
-        let value: V = value.downcast().expect("wrong value type");
-        self.insert(key, value);
-    }
-
-    fn clear(&mut self) {
-        self.clear();
-    }
-
-    fn key_type(&self) -> RuntimeTypeBox {
-        K::runtime_type_box()
-    }
-
-    fn value_type(&self) -> RuntimeTypeBox {
-        V::runtime_type_box()
-    }
-}
-
 trait ReflectMapIterTrait<'a> {
     fn next(&mut self) -> Option<(ReflectValueRef<'a>, ReflectValueRef<'a>)>;
     fn key_type(&self) -> RuntimeTypeBox;
     fn value_type(&self) -> RuntimeTypeBox;
 }
 
-struct ReflectMapIterImpl<'a, K: Eq + Hash + 'static, V: 'static> {
-    iter: hash_map::Iter<'a, K, V>,
-}
-
-impl<'a, K: ProtobufValue + Eq + Hash, V: ProtobufValue> ReflectMapIterTrait<'a>
-    for ReflectMapIterImpl<'a, K, V>
-{
-    fn next(&mut self) -> Option<(ReflectValueRef<'a>, ReflectValueRef<'a>)> {
-        match self.iter.next() {
-            Some((k, v)) => Some((K::as_ref(k), V::as_ref(v))),
-            None => None,
-        }
-    }
-
-    fn key_type(&self) -> RuntimeTypeBox {
-        K::runtime_type_box()
-    }
-
-    fn value_type(&self) -> RuntimeTypeBox {
-        V::runtime_type_box()
-    }
-}
-
 pub struct ReflectMapIter<'a> {
     imp: Box<dyn ReflectMapIterTrait<'a> + 'a>,
 }