Add bytes type to enable {,de}serializing to a byte array

src/bytes.rs

@@ -0,0 +1,171 @@
+use std::ops;
+
+use ser;
+use de;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `Bytes` wraps a `&[u8]` in order to serialize into a byte array.
+pub struct Bytes<'a> {
+    bytes: &'a [u8],
+}
+
+impl<'a, T> From<T> for Bytes<'a> where T: Into<&'a [u8]> {
+    fn from(bytes: T) -> Self {
+        Bytes {
+            bytes: bytes.into(),
+        }
+    }
+}
+
+
+impl<'a> ops::Deref for Bytes<'a> {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { self.bytes }
+}
+
+impl<'a> ser::Serialize for Bytes<'a> {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(self.bytes)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `ByteBuf` wraps a `Vec<u8>` in order to hook into serialize and from deserialize a byte array.
+#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ByteBuf {
+    bytes: Vec<u8>,
+}
+
+impl ByteBuf {
+    pub fn new() -> Self {
+        ByteBuf {
+            bytes: Vec::new(),
+        }
+    }
+
+    pub fn with_capacity(cap: usize) -> Self {
+        ByteBuf {
+            bytes: Vec::with_capacity(cap)
+        }
+    }
+}
+
+impl<T> From<T> for ByteBuf where T: Into<Vec<u8>> {
+    fn from(bytes: T) -> Self {
+        ByteBuf {
+            bytes: bytes.into(),
+        }
+    }
+}
+
+impl AsRef<Vec<u8>> for ByteBuf {
+    fn as_ref(&self) -> &Vec<u8> {
+        &self.bytes
+    }
+}
+
+impl AsRef<[u8]> for ByteBuf {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+impl AsMut<Vec<u8>> for ByteBuf {
+    fn as_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.bytes
+    }
+}
+
+impl AsMut<[u8]> for ByteBuf {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.bytes
+    }
+}
+
+impl Into<Vec<u8>> for ByteBuf {
+    fn into(self) -> Vec<u8> {
+        self.bytes
+    }
+}
+
+impl ops::Deref for ByteBuf {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { &self.bytes[..] }
+}
+
+impl ops::DerefMut for ByteBuf {
+    fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
+}
+
+impl ser::Serialize for ByteBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(&self)
+    }
+}
+
+pub struct ByteBufVisitor;
+
+impl de::Visitor for ByteBufVisitor {
+    type Value = ByteBuf;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: Vec::new(),
+        })
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
+        where V: de::SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = Vec::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.push(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(ByteBuf {
+            bytes: values,
+        })
+    }
+
+    #[inline]
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        self.visit_byte_buf(v.to_vec())
+    }
+
+    #[inline]
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: v,
+        })
+    }
+}
+
+impl de::Deserialize for ByteBuf {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
+        where D: de::Deserializer
+    {
+        deserializer.visit_bytes(ByteBufVisitor)
+    }
+}