1 use std::{
2     fmt::{self, Formatter},
3     hash::{BuildHasher, Hash},
4     marker::PhantomData,
5 };
6 
7 use serde::{
8     de::{MapAccess, SeqAccess, Visitor},
9     ser::{SerializeMap, SerializeSeq},
10     Deserialize, Deserializer, Serialize, Serializer,
11 };
12 
13 use crate::{LinkedHashMap, LinkedHashSet};
14 
15 // LinkedHashMap impls
16 
17 impl<K, V, S> Serialize for LinkedHashMap<K, V, S>
18 where
19     K: Serialize + Eq + Hash,
20     V: Serialize,
21     S: BuildHasher,
22 {
23     #[inline]
serialize<T: Serializer>(&self, serializer: T) -> Result<T::Ok, T::Error>24     fn serialize<T: Serializer>(&self, serializer: T) -> Result<T::Ok, T::Error> {
25         let mut map_serializer = serializer.serialize_map(Some(self.len()))?;
26         for (k, v) in self {
27             map_serializer.serialize_key(k)?;
28             map_serializer.serialize_value(v)?;
29         }
30         map_serializer.end()
31     }
32 }
33 
34 impl<'de, K, V, S> Deserialize<'de> for LinkedHashMap<K, V, S>
35 where
36     K: Deserialize<'de> + Eq + Hash,
37     V: Deserialize<'de>,
38     S: BuildHasher + Default,
39 {
deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>40     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
41         #[derive(Debug)]
42         pub struct LinkedHashMapVisitor<K, V, S> {
43             marker: PhantomData<LinkedHashMap<K, V, S>>,
44         }
45 
46         impl<K, V, S> LinkedHashMapVisitor<K, V, S> {
47             fn new() -> Self {
48                 LinkedHashMapVisitor {
49                     marker: PhantomData,
50                 }
51             }
52         }
53 
54         impl<K, V, S> Default for LinkedHashMapVisitor<K, V, S> {
55             fn default() -> Self {
56                 Self::new()
57             }
58         }
59 
60         impl<'de, K, V, S> Visitor<'de> for LinkedHashMapVisitor<K, V, S>
61         where
62             K: Deserialize<'de> + Eq + Hash,
63             V: Deserialize<'de>,
64             S: BuildHasher + Default,
65         {
66             type Value = LinkedHashMap<K, V, S>;
67 
68             fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
69                 write!(formatter, "a map")
70             }
71 
72             #[inline]
73             fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<Self::Value, M::Error> {
74                 let mut values = LinkedHashMap::with_capacity_and_hasher(
75                     map.size_hint().unwrap_or(0),
76                     S::default(),
77                 );
78 
79                 while let Some((k, v)) = map.next_entry()? {
80                     values.insert(k, v);
81                 }
82 
83                 Ok(values)
84             }
85         }
86 
87         deserializer.deserialize_map(LinkedHashMapVisitor::default())
88     }
89 }
90 
91 // LinkedHashSet impls
92 
93 impl<T, S> Serialize for LinkedHashSet<T, S>
94 where
95     T: Serialize + Eq + Hash,
96     S: BuildHasher,
97 {
98     #[inline]
serialize<U: Serializer>(&self, serializer: U) -> Result<U::Ok, U::Error>99     fn serialize<U: Serializer>(&self, serializer: U) -> Result<U::Ok, U::Error> {
100         let mut seq_serializer = serializer.serialize_seq(Some(self.len()))?;
101         for v in self {
102             seq_serializer.serialize_element(v)?;
103         }
104         seq_serializer.end()
105     }
106 }
107 
108 impl<'de, T, S> Deserialize<'de> for LinkedHashSet<T, S>
109 where
110     T: Deserialize<'de> + Eq + Hash,
111     S: BuildHasher + Default,
112 {
deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>113     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
114         #[derive(Debug)]
115         pub struct LinkedHashSetVisitor<T, S> {
116             marker: PhantomData<LinkedHashSet<T, S>>,
117         }
118 
119         impl<T, S> LinkedHashSetVisitor<T, S> {
120             fn new() -> Self {
121                 LinkedHashSetVisitor {
122                     marker: PhantomData,
123                 }
124             }
125         }
126 
127         impl<T, S> Default for LinkedHashSetVisitor<T, S> {
128             fn default() -> Self {
129                 Self::new()
130             }
131         }
132 
133         impl<'de, T, S> Visitor<'de> for LinkedHashSetVisitor<T, S>
134         where
135             T: Deserialize<'de> + Eq + Hash,
136             S: BuildHasher + Default,
137         {
138             type Value = LinkedHashSet<T, S>;
139 
140             fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
141                 write!(formatter, "a sequence")
142             }
143 
144             #[inline]
145             fn visit_seq<SA: SeqAccess<'de>>(self, mut seq: SA) -> Result<Self::Value, SA::Error> {
146                 let mut values = LinkedHashSet::with_capacity_and_hasher(
147                     seq.size_hint().unwrap_or(0),
148                     S::default(),
149                 );
150 
151                 while let Some(v) = seq.next_element()? {
152                     values.insert(v);
153                 }
154 
155                 Ok(values)
156             }
157         }
158 
159         deserializer.deserialize_seq(LinkedHashSetVisitor::default())
160     }
161 }
162