Fix #329

* This commit adds a feature `dense_serde` which enables serialization
and deserialization of a Uuid as a [u16; 8]

Cargo.toml

@@ -69,6 +69,7 @@ v1 = []
 v3 = ["md5", "rand"]
 v4 = ["rand"]
 v5 = ["sha1", "rand"]
+dense_serde = ["serde"]
 
 # since rust 1.26.0
 u128 = ["byteorder"]

src/lib.rs

@@ -127,7 +127,7 @@ extern crate core;
 extern crate md5;
 #[cfg(feature = "rand")]
 extern crate rand;
-#[cfg(feature = "serde")]
+#[cfg(any(feature = "serde", feature = "dense_serde"))]
 extern crate serde;
 #[cfg(all(feature = "serde", test))]
 extern crate serde_test;

src/serde_support.rs

@@ -11,8 +11,10 @@
 
 use core::fmt;
 use prelude::*;
-use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{de::{self, SeqAccess, Error}, Deserialize, Deserializer, Serialize, Serializer};
+use serde::ser::SerializeTuple;
 
+#[cfg(all(feature = "serde", not(feature = "dense_serde")))]
 impl Serialize for Uuid {
     fn serialize<S: Serializer>(
         &self,
@@ -27,38 +29,104 @@ impl Serialize for Uuid {
     }
 }
 
+#[cfg(feature = "dense_serde")]
+impl Serialize for Uuid {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        if serializer.is_human_readable() {
+            serializer
+                .serialize_str(&self.to_hyphenated().encode_lower(&mut [0; 36]))
+        } else {
+            let mut seq =
+                serializer.serialize_tuple(16)?;
+
+            for byte in self.as_bytes() {
+                seq.serialize_element(byte)?;
+            }
+
+            seq.end()
+        }
+    }
+}
+
+struct UuidStringVisitor;
+
+impl<'vi> de::Visitor<'vi> for UuidStringVisitor {
+    type Value = Uuid;
+
+    fn expecting(
+        &self,
+        formatter: &mut fmt::Formatter,
+    ) -> fmt::Result {
+        write!(formatter, "a UUID string")
+    }
+
+    fn visit_str<E: de::Error>(
+        self,
+        value: &str,
+    ) -> Result<Uuid, E> {
+        value.parse::<Uuid>().map_err(E::custom)
+    }
+
+    fn visit_bytes<E: de::Error>(
+        self,
+        value: &[u8],
+    ) -> Result<Uuid, E> {
+        Uuid::from_slice(value).map_err(E::custom)
+    }
+}
+
+#[cfg(feature = "dense_serde")]
 impl<'de> Deserialize<'de> for Uuid {
     fn deserialize<D: Deserializer<'de>>(
         deserializer: D,
     ) -> Result<Self, D::Error> {
         if deserializer.is_human_readable() {
-            struct UuidStringVisitor;
+            deserializer.deserialize_str(UuidStringVisitor)
+        } else {
+            struct DenseUuidBytesVisitor;
 
-            impl<'vi> de::Visitor<'vi> for UuidStringVisitor {
+            impl<'vi> de::Visitor<'vi> for DenseUuidBytesVisitor {
                 type Value = Uuid;
 
                 fn expecting(
                     &self,
                     formatter: &mut fmt::Formatter,
                 ) -> fmt::Result {
-                    write!(formatter, "a UUID string")
+                    write!(formatter, "tuple")
                 }
 
-                fn visit_str<E: de::Error>(
+                fn visit_seq<A: SeqAccess<'vi>>(
                     self,
-                    value: &str,
-                ) -> Result<Uuid, E> {
-                    value.parse::<Uuid>().map_err(E::custom)
-                }
-
-                fn visit_bytes<E: de::Error>(
-                    self,
-                    value: &[u8],
-                ) -> Result<Uuid, E> {
-                    Uuid::from_slice(value).map_err(E::custom)
+                    mut seq: A,
+                ) -> Result<Self::Value, A::Error> {
+                    if seq.size_hint() == Some(16) {
+                        let mut buf = [0; 16];
+
+                        for i in 0..16 {
+                            buf[i] = seq.next_element().unwrap().unwrap()
+                        }
+
+                        Ok(Uuid::from_bytes(buf))
+                    } else {
+                        Err(Error::custom("Uuid must be 16 bytes long"))
+                    }
                 }
             }
 
+            deserializer.deserialize_tuple(16, DenseUuidBytesVisitor)
+        }
+    }
+}
+
+#[cfg(all(feature = "serde", not(feature = "dense_serde")))]
+impl<'de> Deserialize<'de> for Uuid {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        if deserializer.is_human_readable() {
             deserializer.deserialize_str(UuidStringVisitor)
         } else {
             struct UuidBytesVisitor;
@@ -86,8 +154,8 @@ impl<'de> Deserialize<'de> for Uuid {
     }
 }
 
-#[cfg(test)]
-mod tests {
+#[cfg(all(test, feature = "serde", not(feature = "dense_serde")))]
+mod serde_tests {
     use serde_test;
 
     use prelude::*;
@@ -116,3 +184,53 @@ mod tests {
         );
     }
 }
+
+#[cfg(all(test, feature = "dense_serde"))]
+mod dense_serde_tests {
+    use serde_test;
+
+    use prelude::*;
+
+    #[test]
+    fn test_serialize_readable() {
+        use serde_test::Configure;
+
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+        serde_test::assert_tokens(
+            &u.readable(),
+            &[serde_test::Token::Str(uuid_str)],
+        );
+    }
+
+    #[test]
+    fn test_serialize_compact() {
+        use serde_test::Configure;
+
+        let uuid_bytes = b"F9168C5E-CEB2-4F";
+        let u = Uuid::from_slice(uuid_bytes).unwrap();
+        serde_test::assert_tokens(
+            &u.compact(),
+            &[
+                serde_test::Token::Tuple { len: 16 },
+                serde_test::Token::U8(uuid_bytes[0]),
+                serde_test::Token::U8(uuid_bytes[1]),
+                serde_test::Token::U8(uuid_bytes[2]),
+                serde_test::Token::U8(uuid_bytes[3]),
+                serde_test::Token::U8(uuid_bytes[4]),
+                serde_test::Token::U8(uuid_bytes[5]),
+                serde_test::Token::U8(uuid_bytes[6]),
+                serde_test::Token::U8(uuid_bytes[7]),
+                serde_test::Token::U8(uuid_bytes[8]),
+                serde_test::Token::U8(uuid_bytes[9]),
+                serde_test::Token::U8(uuid_bytes[10]),
+                serde_test::Token::U8(uuid_bytes[11]),
+                serde_test::Token::U8(uuid_bytes[12]),
+                serde_test::Token::U8(uuid_bytes[13]),
+                serde_test::Token::U8(uuid_bytes[14]),
+                serde_test::Token::U8(uuid_bytes[15]),
+                serde_test::Token::TupleEnd
+            ],
+        )
+    }
+}