Implement optional Serde 1.0 support

Cargo.toml

@@ -11,13 +11,15 @@ description = "A hash table with consistent order and fast iteration."
 bench = false
 
 [dependencies]
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
 itertools = "0.5.1"
 rand = "0.3"
 quickcheck = { version = "0.4", default-features = false }
 fnv = "1.0"
 lazy_static = "0.2"
+serde_test = "1.0.5"
 
 [features]
 # for testing only, of course

src/lib.rs

@@ -2,6 +2,8 @@
 #![doc(html_root_url = "https://docs.rs/ordermap/0.2/")]
 
 mod macros;
+#[cfg(feature = "serde")]
+mod serde;
 mod util;
 
 use std::hash::Hash;

src/serde.rs

@@ -0,0 +1,63 @@
+
+extern crate serde;
+
+use self::serde::ser::{Serialize, Serializer, SerializeMap};
+use self::serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
+
+use std::fmt::{self, Formatter};
+use std::hash::{BuildHasher, Hash};
+use std::marker::PhantomData;
+
+use OrderMap;
+
+impl<K, V, S> Serialize for OrderMap<K, V, S>
+    where K: Serialize + Hash + Eq,
+          V: Serialize,
+          S: BuildHasher
+{
+    fn serialize<T>(&self, serializer: T) -> Result<T::Ok, T::Error>
+        where T: Serializer
+    {
+        let mut map_serializer = try!(serializer.serialize_map(Some(self.len())));
+        for (key, value) in self {
+            try!(map_serializer.serialize_entry(key, value));
+        }
+        map_serializer.end()
+    }
+}
+
+struct OrderMapVisitor<K, V>(PhantomData<(K, V)>);
+
+impl<'de, K, V> Visitor<'de> for OrderMapVisitor<K, V>
+    where K: Deserialize<'de> + Eq + Hash,
+          V: Deserialize<'de>
+{
+    type Value = OrderMap<K, V>;
+
+    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+        write!(formatter, "a map")
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where A: MapAccess<'de>
+    {
+        let mut values = OrderMap::with_capacity(map.size_hint().unwrap_or(0));
+
+        while let Some((key, value)) = try!(map.next_entry()) {
+            values.insert(key, value);
+        }
+
+        Ok(values)
+    }
+}
+
+impl<'de, K, V> Deserialize<'de> for OrderMap<K, V>
+    where K: Deserialize<'de> + Eq + Hash,
+          V: Deserialize<'de>
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where D: Deserializer<'de>
+    {
+        deserializer.deserialize_map(OrderMapVisitor(PhantomData))
+    }
+}

tests/serde.rs

@@ -0,0 +1,19 @@
+#![cfg(feature = "serde")]
+
+#[macro_use]
+extern crate ordermap;
+extern crate serde_test;
+
+use serde_test::{Token, assert_tokens};
+
+#[test]
+fn test_serde() {
+    let map = ordermap! { 1 => 2, 3 => 4 };
+    assert_tokens(&map,
+                  &[Token::Map { len: Some(2) },
+                    Token::I32(1),
+                    Token::I32(2),
+                    Token::I32(3),
+                    Token::I32(4),
+                    Token::MapEnd]);
+}