From 3d4346808fba91f0121e72bb1d775b90d7c3fded Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Mon, 12 Dec 2016 13:26:26 -0500
Subject: [PATCH] More efficient serialize_bytes (#90)

* Update to serde_derive

* Fix missing Encoder and Decoder imports

* Add test for serializing bytes

* More efficient serialize_bytes

Reported in #serde: blank_name2 tried serializing
`HashMap<String, HashSet<Bytes>>` vs `HashMap<String, HashSet<&Path>>`,
the `&Path` version was done in ~.6 seconds while the
`&[u8]` one took a full 3 seconds more.
---
 Cargo.toml          |  2 +-
 src/serde/writer.rs | 14 ++++----------
 tests/test.rs       | 20 +++++++++++++++++---
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index c4befb7..bb54fd8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,7 +23,7 @@ version = "0.8.*"
 optional = true
 
 [dev-dependencies]
-serde_macros = "0.8.*"
+serde_derive = "0.8.*"
 
 [features]
 default = ["rustc-serialize", "serde"]
diff --git a/src/serde/writer.rs b/src/serde/writer.rs
index 0c3ae3c..58666eb 100644
--- a/src/serde/writer.rs
+++ b/src/serde/writer.rs
@@ -163,11 +163,8 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
     }
 
     fn serialize_bytes(&mut self, v: &[u8]) -> SerializeResult<()> {
-        let mut state = try!(self.serialize_seq(Some(v.len())));
-        for c in v {
-            try!(self.serialize_seq_elt(&mut state, c));
-        }
-        self.serialize_seq_end(state)
+        try!(self.serialize_usize(v.len()));
+        self.writer.write_all(v).map_err(SerializeError::IoError)
     }
 
     fn serialize_none(&mut self) -> SerializeResult<()> {
@@ -440,11 +437,8 @@ impl serde::Serializer for SizeChecker {
     }
 
     fn serialize_bytes(&mut self, v: &[u8]) -> SerializeResult<()> {
-        let mut state = try!(self.serialize_seq(Some(v.len())));
-        for c in v {
-            try!(self.serialize_seq_elt(&mut state, c));
-        }
-        self.serialize_seq_end(state)
+        try!(self.add_value(0 as u64));
+        self.add_raw(v.len())
     }
 
     fn serialize_none(&mut self) -> SerializeResult<()> {
diff --git a/tests/test.rs b/tests/test.rs
index 976bb8f..13c0dc1 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,5 +1,7 @@
-#![feature(plugin, custom_derive, custom_attribute)]
-#![plugin(serde_macros)]
+#![feature(proc_macro)]
+
+#[macro_use]
+extern crate serde_derive;
 
 extern crate bincode;
 extern crate rustc_serialize;
@@ -9,7 +11,7 @@ use std::fmt::Debug;
 use std::collections::HashMap;
 use std::ops::Deref;
 
-use rustc_serialize::{Encodable, Decodable};
+use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
 
 use bincode::{RefBox, StrBox, SliceBox};
 
@@ -516,6 +518,18 @@ fn path_buf() {
     assert!(path.to_str() == decoded.to_str());
 }
 
+#[test]
+fn bytes() {
+    let data = b"abc\0123";
+    let b = bincode::rustc_serialize::encode(&data, Infinite).unwrap();
+    let s = bincode::serde::serialize(&data, Infinite).unwrap();
+    assert_eq!(b, s);
+
+    use serde::bytes::Bytes;
+    let s2 = bincode::serde::serialize(&Bytes::new(data), Infinite).unwrap();
+    assert_eq!(s, s2);
+}
+
 #[test]
 fn test_manual_enum_encoding() {
     #[derive(PartialEq)]