Add serde support behind serde feature (#96)

.travis.yml

@@ -33,6 +33,9 @@ matrix:
     - env: RUST_TEST_THREADS=1 TARGET=powerpc-unknown-linux-gnu
     - env: RUST_TEST_THREADS=1 TARGET=powerpc64-unknown-linux-gnu
 
+    # Serde implementation
+    - env: EXTRA_ARGS="--features serde"
+
 before_install: set -e
 
 install:

Cargo.toml

@@ -22,6 +22,7 @@ categories = ["network-programming", "data-structures"]
 [dependencies]
 byteorder = "1.0.0"
 iovec = "0.1"
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
-tokio-core = "0.1.0"
+serde_test = "1.0"

README.md

@@ -24,6 +24,15 @@ extern crate bytes;
 use bytes::{Bytes, BytesMut, Buf, BufMut};
 ```
 
+## Serde support
+
+Serde support is optional and disabled by default. To enable use the feature `serde`.
+
+```toml
+[dependencies]
+bytes = { version = "0.4", features = ["serde"] }
+```
+
 # License
 
 `bytes` is primarily distributed under the terms of both the MIT license and the

ci/script.sh

@@ -3,13 +3,13 @@
 set -ex
 
 main() {
-    cross build --target $TARGET
+    cross build --target $TARGET $EXTRA_ARGS
 
     if [ ! -z $DISABLE_TESTS ]; then
         return
     fi
 
-    cross test --target $TARGET
+    cross test --target $TARGET $EXTRA_ARGS
 }
 
 # we don't run the "test phase" when doing deploys

src/lib.rs

@@ -93,3 +93,8 @@ mod debug;
 pub use bytes::{Bytes, BytesMut};
 
 pub use byteorder::{ByteOrder, BigEndian, LittleEndian};
+
+// Optional Serde support
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+pub mod serde;

src/serde.rs

@@ -0,0 +1,82 @@
+extern crate serde;
+
+use std::{cmp, fmt};
+use self::serde::{Serialize, Serializer, Deserialize, Deserializer, de};
+use super::{Bytes, BytesMut};
+
+macro_rules! serde_impl {
+    ($ty:ident, $visitor_ty:ident) => (
+        impl Serialize for $ty {
+            #[inline]
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where S: Serializer
+            {
+                serializer.serialize_bytes(&self)
+            }
+        }
+
+        struct $visitor_ty;
+
+        impl<'de> de::Visitor<'de> for $visitor_ty {
+            type Value = $ty;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("byte array")
+            }
+
+            #[inline]
+            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+                where V: de::SeqAccess<'de>
+            {
+                let len = cmp::min(seq.size_hint().unwrap_or(0), 4096);
+                let mut values = Vec::with_capacity(len);
+
+                while let Some(value) = try!(seq.next_element()) {
+                    values.push(value);
+                }
+
+                Ok(values.into())
+            }
+
+            #[inline]
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+        }
+
+        impl<'de> Deserialize<'de> for $ty {
+            #[inline]
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
+                where D: Deserializer<'de>
+            {
+                deserializer.deserialize_byte_buf($visitor_ty)
+            }
+        }
+    );
+}
+
+serde_impl!(Bytes, BytesVisitor);
+serde_impl!(BytesMut, BytesMutVisitor);

tests/test_serde.rs

@@ -0,0 +1,21 @@
+#![cfg(feature = "serde")]
+
+extern crate bytes;
+extern crate serde_test;
+use serde_test::{Token, assert_tokens};
+
+#[test]
+fn test_ser_de_empty() {
+    let b = bytes::Bytes::new();
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+    let b = bytes::BytesMut::with_capacity(0);
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+}
+
+#[test]
+fn test_ser_de() {
+    let b = bytes::Bytes::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+    let b = bytes::BytesMut::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+}