tafia · tafia · Feb 9, 2017 · Feb 7, 2017 · Feb 7, 2017 · Feb 7, 2017
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "quick-protobuf"
 description = "A pure Rust protobuf (de)serializer. Quick."
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Johann Tuffe <tafia973@gmail.com>"]
 keywords = ["protobuf", "parser"]
 license = "MIT"

diff --git a/Changelog.md b/Changelog.md
@@ -15,6 +15,8 @@
 - feat: break codegen when reserved fields conflict
 - feat: support imports in proto files
 - feat: support packages by encapsulating into rust modules
+- feat: support map
+- refactor: major refatorings of codegen
 
 ## 0.2.0
 - feat: do not allocate for bytes and string field types

diff --git a/benches/perftest.rs b/benches/perftest.rs
@@ -131,7 +131,7 @@ fn generate_optional_messages() -> Vec<TestOptionalMessages> {
 perfbench!(generate_optional_messages, TestOptionalMessages, write_optional_messages, read_optional_messages);
 
 fn generate_strings() -> Vec<TestStrings<'static>> {
-    let mut s = "hello world from quick-protobuf!!!".split('_').cycle().map(|s| Cow::Borrowed(s));
+    let mut s = "hello world from quick-protobuf!!!".split(' ').cycle().map(|s| Cow::Borrowed(s));
     (1..100).map(|_| TestStrings { 
         s1: s.by_ref().next(),
         s2: s.by_ref().next(),
@@ -142,7 +142,7 @@ fn generate_strings() -> Vec<TestStrings<'static>> {
 perfbench!(generate_strings, TestStrings, write_strings, read_strings);
 
 fn generate_small_bytes() -> Vec<TestBytes<'static>> {
-    let mut s = "hello world from quick-protobuf!!!".split('_').cycle()
+    let mut s = "hello world from quick-protobuf!!!".split(' ').cycle()
         .map(|s| Cow::Borrowed(s.as_bytes()));
     (1..800).map(|_| TestBytes { b1: s.by_ref().next() })
         .collect()
@@ -151,7 +151,7 @@ fn generate_small_bytes() -> Vec<TestBytes<'static>> {
 perfbench!(generate_small_bytes, TestBytes, write_small_bytes, read_small_bytes);
 
 fn generate_large_bytes() -> Vec<TestBytes<'static>> {
-    let mut s = "hello world from quick-protobuf!!!".split('_').cycle().map(|s| s.as_bytes());
+    let mut s = "hello world from quick-protobuf!!!".split(' ').cycle().map(|s| s.as_bytes());
     (1..30).map(|_| TestBytes { 
         b1: Some(Cow::Owned(s.by_ref().take(500).fold(Vec::new(), |mut cur, nxt| {
                 cur.extend_from_slice(nxt);
@@ -162,6 +162,15 @@ fn generate_large_bytes() -> Vec<TestBytes<'static>> {
 
 perfbench!(generate_large_bytes, TestBytes, write_large_bytes, read_large_bytes);
 
+fn generate_map() -> Vec<TestMap<'static>> {
+    let mut s = "hello world from quick-protobuf!!!".split(' ').cycle();
+    (1..30).map(|_| TestMap { 
+        value: s.by_ref().take(500).map(|s| (Cow::Owned(s.to_string()), s.len() as u32)).collect()
+    }).collect()
+}
+
+perfbench!(generate_map, TestMap, write_map, read_map);
+
 fn generate_all() -> Vec<PerftestData<'static>> {
     vec![PerftestData {
         test1: generate_test1(),
@@ -172,6 +181,7 @@ fn generate_all() -> Vec<PerftestData<'static>> {
         test_repeated_packed_int32: generate_repeated_packed_int32(),
         test_small_bytearrays: generate_small_bytes(),
         test_large_bytearrays: generate_large_bytes(),
+        test_map: generate_map(),
     }]
 }
 

diff --git a/benches/perftest_data/mod.rs b/benches/perftest_data/mod.rs
@@ -6,6 +6,7 @@
 
 use std::io::{Write};
 use std::borrow::Cow;
+use std::collections::HashMap;
 use quick_protobuf::{MessageWrite, BytesReader, Writer, Result};
 use quick_protobuf::sizeofs::*;
 
@@ -30,11 +31,11 @@ impl Test1 {
 
 impl MessageWrite for Test1 {
     fn get_size(&self) -> usize {
-        self.value.as_ref().map_or(0, |m| 1 + sizeof_int32(*m))
+        self.value.as_ref().map_or(0, |m| 1 + sizeof_varint(*m as u64))
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.value { r.write_int32_with_tag(8, *s)?; }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.value { w.write_with_tag(8, |w| w.write_int32(*s))?; }
         Ok(())
     }
 }
@@ -60,11 +61,11 @@ impl TestRepeatedBool {
 
 impl MessageWrite for TestRepeatedBool {
     fn get_size(&self) -> usize {
-        self.values.iter().map(|s| 1 + sizeof_bool(*s)).sum::<usize>()
+        self.values.iter().map(|s| 1 + sizeof_varint(*s as u64)).sum::<usize>()
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        for s in &self.values { r.write_bool_with_tag(8, *s)? }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        for s in &self.values { w.write_with_tag(8, |w| w.write_bool(*s))?; }
         Ok(())
     }
 }
@@ -90,11 +91,11 @@ impl TestRepeatedPackedInt32 {
 
 impl MessageWrite for TestRepeatedPackedInt32 {
     fn get_size(&self) -> usize {
-        if self.values.is_empty() { 0 } else { 1 + sizeof_var_length(self.values.iter().map(|s| sizeof_int32(*s)).sum::<usize>()) }
+        if self.values.is_empty() { 0 } else { 1 + sizeof_len(self.values.iter().map(|s| sizeof_varint(*s as u64)).sum::<usize>()) }
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        r.write_packed_repeated_field_with_tag(10, &self.values, |r, m| r.write_int32(*m), &|m| sizeof_int32(*m))?;
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        w.write_packed_with_tag(10, &self.values, |w, m| w.write_int32(*m), &|m| sizeof_varint(*m as u64))?;
         Ok(())
     }
 }
@@ -124,15 +125,15 @@ impl TestRepeatedMessages {
 
 impl MessageWrite for TestRepeatedMessages {
     fn get_size(&self) -> usize {
-        self.messages1.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.messages2.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.messages3.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
+        self.messages1.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.messages2.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.messages3.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        for s in &self.messages1 { r.write_message_with_tag(10, s)? }
-        for s in &self.messages2 { r.write_message_with_tag(18, s)? }
-        for s in &self.messages3 { r.write_message_with_tag(26, s)? }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        for s in &self.messages1 { w.write_with_tag(10, |w| w.write_message(s))?; }
+        for s in &self.messages2 { w.write_with_tag(18, |w| w.write_message(s))?; }
+        for s in &self.messages3 { w.write_with_tag(26, |w| w.write_message(s))?; }
         Ok(())
     }
 }
@@ -162,15 +163,15 @@ impl TestOptionalMessages {
 
 impl MessageWrite for TestOptionalMessages {
     fn get_size(&self) -> usize {
-        self.message1.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.get_size()))
-        + self.message2.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.get_size()))
-        + self.message3.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.get_size()))
+        self.message1.as_ref().map_or(0, |m| 1 + sizeof_len(m.get_size()))
+        + self.message2.as_ref().map_or(0, |m| 1 + sizeof_len(m.get_size()))
+        + self.message3.as_ref().map_or(0, |m| 1 + sizeof_len(m.get_size()))
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.message1 { r.write_message_with_tag(10, &**s)?; }
-        if let Some(ref s) = self.message2 { r.write_message_with_tag(18, &**s)?; }
-        if let Some(ref s) = self.message3 { r.write_message_with_tag(26, &**s)?; }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.message1 { w.write_with_tag(10, |w| w.write_message(&**s))?; }
+        if let Some(ref s) = self.message2 { w.write_with_tag(18, |w| w.write_message(&**s))?; }
+        if let Some(ref s) = self.message3 { w.write_with_tag(26, |w| w.write_message(&**s))?; }
         Ok(())
     }
 }
@@ -187,9 +188,9 @@ impl<'a> TestStrings<'a> {
         let mut msg = Self::default();
         while !r.is_eof() {
             match r.next_tag(bytes) {
-                Ok(10) => msg.s1 = Some(Cow::Borrowed(r.read_string(bytes)?)),
-                Ok(18) => msg.s2 = Some(Cow::Borrowed(r.read_string(bytes)?)),
-                Ok(26) => msg.s3 = Some(Cow::Borrowed(r.read_string(bytes)?)),
+                Ok(10) => msg.s1 = Some(r.read_string(bytes).map(Cow::Borrowed)?),
+                Ok(18) => msg.s2 = Some(r.read_string(bytes).map(Cow::Borrowed)?),
+                Ok(26) => msg.s3 = Some(r.read_string(bytes).map(Cow::Borrowed)?),
                 Ok(t) => { r.read_unknown(bytes, t)?; }
                 Err(e) => return Err(e),
             }
@@ -200,15 +201,15 @@ impl<'a> TestStrings<'a> {
 
 impl<'a> MessageWrite for TestStrings<'a> {
     fn get_size(&self) -> usize {
-        self.s1.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.len()))
-        + self.s2.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.len()))
-        + self.s3.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.len()))
+        self.s1.as_ref().map_or(0, |m| 1 + sizeof_len(m.len()))
+        + self.s2.as_ref().map_or(0, |m| 1 + sizeof_len(m.len()))
+        + self.s3.as_ref().map_or(0, |m| 1 + sizeof_len(m.len()))
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.s1 { r.write_string_with_tag(10, s)?; }
-        if let Some(ref s) = self.s2 { r.write_string_with_tag(18, s)?; }
-        if let Some(ref s) = self.s3 { r.write_string_with_tag(26, s)?; }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.s1 { w.write_with_tag(10, |w| w.write_string(&**s))?; }
+        if let Some(ref s) = self.s2 { w.write_with_tag(18, |w| w.write_string(&**s))?; }
+        if let Some(ref s) = self.s3 { w.write_with_tag(26, |w| w.write_string(&**s))?; }
         Ok(())
     }
 }
@@ -223,7 +224,7 @@ impl<'a> TestBytes<'a> {
         let mut msg = Self::default();
         while !r.is_eof() {
             match r.next_tag(bytes) {
-                Ok(10) => msg.b1 = Some(Cow::Borrowed(r.read_bytes(bytes)?)),
+                Ok(10) => msg.b1 = Some(r.read_bytes(bytes).map(Cow::Borrowed)?),
                 Ok(t) => { r.read_unknown(bytes, t)?; }
                 Err(e) => return Err(e),
             }
@@ -234,11 +235,44 @@ impl<'a> TestBytes<'a> {
 
 impl<'a> MessageWrite for TestBytes<'a> {
     fn get_size(&self) -> usize {
-        self.b1.as_ref().map_or(0, |m| 1 + sizeof_var_length(m.len()))
+        self.b1.as_ref().map_or(0, |m| 1 + sizeof_len(m.len()))
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        if let Some(ref s) = self.b1 { r.write_bytes_with_tag(10, s)?; }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        if let Some(ref s) = self.b1 { w.write_with_tag(10, |w| w.write_bytes(&**s))?; }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct TestMap<'a> {
+    pub value: HashMap<Cow<'a, str>, u32>,
+}
+
+impl<'a> TestMap<'a> {
+    pub fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
+        let mut msg = Self::default();
+        while !r.is_eof() {
+            match r.next_tag(bytes) {
+                Ok(10) => {
+                    let (key, value) = r.read_map(bytes, |r, bytes| r.read_string(bytes).map(Cow::Borrowed), |r, bytes| r.read_uint32(bytes))?;
+                    msg.value.insert(key, value);
+                }
+                Ok(t) => { r.read_unknown(bytes, t)?; }
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(msg)
+    }
+}
+
+impl<'a> MessageWrite for TestMap<'a> {
+    fn get_size(&self) -> usize {
+        self.value.iter().map(|(k, v)| 1 + sizeof_len(2 + sizeof_len(k.len()) + sizeof_varint(*v as u64))).sum::<usize>()
+    }
+
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        for (k, v) in self.value.iter() { w.write_with_tag(10, |w| w.write_map(2 + sizeof_len(k.len()) + sizeof_varint(*v as u64), 10, |w| w.write_string(&**k), 16, |w| w.write_uint32(*v)))?; }
         Ok(())
     }
 }
@@ -253,6 +287,7 @@ pub struct PerftestData<'a> {
     pub test_repeated_packed_int32: Vec<TestRepeatedPackedInt32>,
     pub test_small_bytearrays: Vec<TestBytes<'a>>,
     pub test_large_bytearrays: Vec<TestBytes<'a>>,
+    pub test_map: Vec<TestMap<'a>>,
 }
 
 impl<'a> PerftestData<'a> {
@@ -268,6 +303,7 @@ impl<'a> PerftestData<'a> {
                 Ok(50) => msg.test_repeated_packed_int32.push(r.read_message(bytes, TestRepeatedPackedInt32::from_reader)?),
                 Ok(58) => msg.test_small_bytearrays.push(r.read_message(bytes, TestBytes::from_reader)?),
                 Ok(66) => msg.test_large_bytearrays.push(r.read_message(bytes, TestBytes::from_reader)?),
+                Ok(74) => msg.test_map.push(r.read_message(bytes, TestMap::from_reader)?),
                 Ok(t) => { r.read_unknown(bytes, t)?; }
                 Err(e) => return Err(e),
             }
@@ -278,25 +314,27 @@ impl<'a> PerftestData<'a> {
 
 impl<'a> MessageWrite for PerftestData<'a> {
     fn get_size(&self) -> usize {
-        self.test1.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_repeated_bool.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_repeated_messages.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_optional_messages.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_strings.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_repeated_packed_int32.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_small_bytearrays.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
-        + self.test_large_bytearrays.iter().map(|s| 1 + sizeof_var_length(s.get_size())).sum::<usize>()
+        self.test1.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_repeated_bool.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_repeated_messages.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_optional_messages.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_strings.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_repeated_packed_int32.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_small_bytearrays.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_large_bytearrays.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
+        + self.test_map.iter().map(|s| 1 + sizeof_len(s.get_size())).sum::<usize>()
     }
 
-    fn write_message<W: Write>(&self, r: &mut Writer<W>) -> Result<()> {
-        for s in &self.test1 { r.write_message_with_tag(10, s)? }
-        for s in &self.test_repeated_bool { r.write_message_with_tag(18, s)? }
-        for s in &self.test_repeated_messages { r.write_message_with_tag(26, s)? }
-        for s in &self.test_optional_messages { r.write_message_with_tag(34, s)? }
-        for s in &self.test_strings { r.write_message_with_tag(42, s)? }
-        for s in &self.test_repeated_packed_int32 { r.write_message_with_tag(50, s)? }
-        for s in &self.test_small_bytearrays { r.write_message_with_tag(58, s)? }
-        for s in &self.test_large_bytearrays { r.write_message_with_tag(66, s)? }
+    fn write_message<W: Write>(&self, w: &mut Writer<W>) -> Result<()> {
+        for s in &self.test1 { w.write_with_tag(10, |w| w.write_message(s))?; }
+        for s in &self.test_repeated_bool { w.write_with_tag(18, |w| w.write_message(s))?; }
+        for s in &self.test_repeated_messages { w.write_with_tag(26, |w| w.write_message(s))?; }
+        for s in &self.test_optional_messages { w.write_with_tag(34, |w| w.write_message(s))?; }
+        for s in &self.test_strings { w.write_with_tag(42, |w| w.write_message(s))?; }
+        for s in &self.test_repeated_packed_int32 { w.write_with_tag(50, |w| w.write_message(s))?; }
+        for s in &self.test_small_bytearrays { w.write_with_tag(58, |w| w.write_message(s))?; }
+        for s in &self.test_large_bytearrays { w.write_with_tag(66, |w| w.write_message(s))?; }
+        for s in &self.test_map { w.write_with_tag(74, |w| w.write_message(s))?; }
         Ok(())
     }
 }
diff --git a/benches/perftest_data/perftest_data.proto b/benches/perftest_data/perftest_data.proto
@@ -32,6 +32,10 @@ message TestBytes {
     optional bytes b1 = 1;
 }
 
+message TestMap {
+    map<string, uint32> value = 1;
+}
+
 message PerftestData {
     repeated Test1 test1 = 1;
     repeated TestRepeatedBool test_repeated_bool = 2;
@@ -41,4 +45,5 @@ message PerftestData {
     repeated TestRepeatedPackedInt32 test_repeated_packed_int32 = 6;
     repeated TestBytes test_small_bytearrays = 7;
     repeated TestBytes test_large_bytearrays = 8;
+    repeated TestMap test_map = 9;
 }