vendor/hashbrown-0.9.1/src/external_trait_impls/serde.rs

   1 mod size_hint {
   2     use core::cmp;
   3
   4     /// This presumably exists to prevent denial of service attacks.
   5     ///
   6     /// Original discussion: https://github.com/serde-rs/serde/issues/1114.
   7     #[cfg_attr(feature = "inline-more", inline)]
   8     pub(super) fn cautious(hint: Option<usize>) -> usize {
   9         cmp::min(hint.unwrap_or(0), 4096)
  10     }
  11 }
  12
  13 mod map {
  14     use core::fmt;
  15     use core::hash::{BuildHasher, Hash};
  16     use core::marker::PhantomData;
  17     use serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
  18     use serde::ser::{Serialize, Serializer};
  19
  20     use crate::hash_map::HashMap;
  21
  22     use super::size_hint;
  23
  24     impl<K, V, H> Serialize for HashMap<K, V, H>
  25     where
  26         K: Serialize + Eq + Hash,
  27         V: Serialize,
  28         H: BuildHasher,
  29     {
  30         #[cfg_attr(feature = "inline-more", inline)]
  31         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  32         where
  33             S: Serializer,
  34         {
  35             serializer.collect_map(self)
  36         }
  37     }
  38
  39     impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S>
  40     where
  41         K: Deserialize<'de> + Eq + Hash,
  42         V: Deserialize<'de>,
  43         S: BuildHasher + Default,
  44     {
  45         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  46         where
  47             D: Deserializer<'de>,
  48         {
  49             struct MapVisitor<K, V, S> {
  50                 marker: PhantomData<HashMap<K, V, S>>,
  51             }
  52
  53             impl<'de, K, V, S> Visitor<'de> for MapVisitor<K, V, S>
  54             where
  55                 K: Deserialize<'de> + Eq + Hash,
  56                 V: Deserialize<'de>,
  57                 S: BuildHasher + Default,
  58             {
  59                 type Value = HashMap<K, V, S>;
  60
  61                 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
  62                     formatter.write_str("a map")
  63                 }
  64
  65                 #[cfg_attr(feature = "inline-more", inline)]
  66                 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
  67                 where
  68                     A: MapAccess<'de>,
  69                 {
  70                     let mut values = HashMap::with_capacity_and_hasher(
  71                         size_hint::cautious(map.size_hint()),
  72                         S::default(),
  73                     );
  74
  75                     while let Some((key, value)) = map.next_entry()? {
  76                         values.insert(key, value);
  77                     }
  78
  79                     Ok(values)
  80                 }
  81             }
  82
  83             let visitor = MapVisitor {
  84                 marker: PhantomData,
  85             };
  86             deserializer.deserialize_map(visitor)
  87         }
  88     }
  89 }
  90
  91 mod set {
  92     use core::fmt;
  93     use core::hash::{BuildHasher, Hash};
  94     use core::marker::PhantomData;
  95     use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
  96     use serde::ser::{Serialize, Serializer};
  97
  98     use crate::hash_set::HashSet;
  99
 100     use super::size_hint;
 101
 102     impl<T, H> Serialize for HashSet<T, H>
 103     where
 104         T: Serialize + Eq + Hash,
 105         H: BuildHasher,
 106     {
 107         #[cfg_attr(feature = "inline-more", inline)]
 108         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 109         where
 110             S: Serializer,
 111         {
 112             serializer.collect_seq(self)
 113         }
 114     }
 115
 116     impl<'de, T, S> Deserialize<'de> for HashSet<T, S>
 117     where
 118         T: Deserialize<'de> + Eq + Hash,
 119         S: BuildHasher + Default,
 120     {
 121         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 122         where
 123             D: Deserializer<'de>,
 124         {
 125             struct SeqVisitor<T, S> {
 126                 marker: PhantomData<HashSet<T, S>>,
 127             }
 128
 129             impl<'de, T, S> Visitor<'de> for SeqVisitor<T, S>
 130             where
 131                 T: Deserialize<'de> + Eq + Hash,
 132                 S: BuildHasher + Default,
 133             {
 134                 type Value = HashSet<T, S>;
 135
 136                 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 137                     formatter.write_str("a sequence")
 138                 }
 139
 140                 #[cfg_attr(feature = "inline-more", inline)]
 141                 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 142                 where
 143                     A: SeqAccess<'de>,
 144                 {
 145                     let mut values = HashSet::with_capacity_and_hasher(
 146                         size_hint::cautious(seq.size_hint()),
 147                         S::default(),
 148                     );
 149
 150                     while let Some(value) = seq.next_element()? {
 151                         values.insert(value);
 152                     }
 153
 154                     Ok(values)
 155                 }
 156             }
 157
 158             let visitor = SeqVisitor {
 159                 marker: PhantomData,
 160             };
 161             deserializer.deserialize_seq(visitor)
 162         }
 163
 164         fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
 165         where
 166             D: Deserializer<'de>,
 167         {
 168             struct SeqInPlaceVisitor<'a, T, S>(&'a mut HashSet<T, S>);
 169
 170             impl<'a, 'de, T, S> Visitor<'de> for SeqInPlaceVisitor<'a, T, S>
 171             where
 172                 T: Deserialize<'de> + Eq + Hash,
 173                 S: BuildHasher + Default,
 174             {
 175                 type Value = ();
 176
 177                 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 178                     formatter.write_str("a sequence")
 179                 }
 180
 181                 #[cfg_attr(feature = "inline-more", inline)]
 182                 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 183                 where
 184                     A: SeqAccess<'de>,
 185                 {
 186                     self.0.clear();
 187                     self.0.reserve(size_hint::cautious(seq.size_hint()));
 188
 189                     while let Some(value) = seq.next_element()? {
 190                         self.0.insert(value);
 191                     }
 192
 193                     Ok(())
 194                 }
 195             }
 196
 197             deserializer.deserialize_seq(SeqInPlaceVisitor(place))
 198         }
 199     }
 200 }