1 //! An optional implementation of serialization/deserialization. 2 3 extern crate serde; 4 5 use std::fmt::{Formatter, Result as FmtResult}; 6 use std::marker::PhantomData; 7 use std::hash::{BuildHasher, Hash}; 8 9 use super::LinkedHashMap; 10 11 use self::serde::{Serialize, Serializer, Deserialize, Deserializer}; 12 use self::serde::ser::SerializeMap; 13 use self::serde::de::{Visitor, MapAccess, Error}; 14 15 impl<K, V, S> Serialize for LinkedHashMap<K, V, S> 16 where K: Serialize + Eq + Hash, 17 V: Serialize, 18 S: BuildHasher 19 { 20 #[inline] serialize<T>(&self, serializer:T) -> Result<T::Ok, T::Error> where T: Serializer,21 fn serialize<T>(&self, serializer:T) -> Result<T::Ok, T::Error> 22 where T: Serializer, 23 { 24 let mut map_serializer = try!(serializer.serialize_map(Some(self.len()))); 25 for (k, v) in self { 26 try!(map_serializer.serialize_key(k)); 27 try!(map_serializer.serialize_value(v)); 28 } 29 map_serializer.end() 30 } 31 } 32 33 #[derive(Debug)] 34 /// `serde::de::Visitor` for a linked hash map. 35 pub struct LinkedHashMapVisitor<K, V> { 36 marker: PhantomData<LinkedHashMap<K, V>>, 37 } 38 39 impl<K, V> LinkedHashMapVisitor<K, V> { 40 /// Creates a new visitor for a linked hash map. new() -> Self41 pub fn new() -> Self { 42 LinkedHashMapVisitor { 43 marker: PhantomData, 44 } 45 } 46 } 47 48 impl<K, V> Default for LinkedHashMapVisitor<K, V> { default() -> Self49 fn default() -> Self { 50 LinkedHashMapVisitor::new() 51 } 52 } 53 54 impl<'de, K, V> Visitor<'de> for LinkedHashMapVisitor<K, V> 55 where K: Deserialize<'de> + Eq + Hash, 56 V: Deserialize<'de>, 57 { 58 type Value = LinkedHashMap<K, V>; 59 expecting(&self, formatter: &mut Formatter) -> FmtResult60 fn expecting(&self, formatter: &mut Formatter) -> FmtResult { 61 write!(formatter, "a map") 62 } 63 64 #[inline] visit_unit<E>(self) -> Result<Self::Value, E> where E: Error,65 fn visit_unit<E>(self) -> Result<Self::Value, E> 66 where E: Error, 67 { 68 Ok(LinkedHashMap::new()) 69 } 70 71 #[inline] visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> where M: MapAccess<'de>,72 fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> 73 where M: MapAccess<'de>, 74 { 75 let mut values = LinkedHashMap::with_capacity(map.size_hint().unwrap_or(0)); 76 77 while let Some((key, value)) = map.next_entry()? { 78 values.insert(key, value); 79 } 80 81 Ok(values) 82 } 83 } 84 85 impl<'de, K, V> Deserialize<'de> for LinkedHashMap<K, V> 86 where K: Deserialize<'de> + Eq + Hash, 87 V: Deserialize<'de>, 88 { deserialize<D>(deserializer: D) -> Result<LinkedHashMap<K, V>, D::Error> where D: Deserializer<'de>,89 fn deserialize<D>(deserializer: D) -> Result<LinkedHashMap<K, V>, D::Error> 90 where D: Deserializer<'de>, 91 { 92 deserializer.deserialize_map(LinkedHashMapVisitor::new()) 93 } 94 } 95