foundry_compilers_artifacts_solc/
serde_helpers.rs

1//! Serde helpers.
2
3use alloy_primitives::Bytes;
4use serde::{Deserialize, Deserializer};
5
6pub fn deserialize_bytes<'de, D>(d: D) -> Result<Bytes, D::Error>
7where
8    D: Deserializer<'de>,
9{
10    String::deserialize(d)?.parse::<Bytes>().map_err(serde::de::Error::custom)
11}
12
13pub fn deserialize_opt_bytes<'de, D>(d: D) -> Result<Option<Bytes>, D::Error>
14where
15    D: Deserializer<'de>,
16{
17    let value = Option::<String>::deserialize(d)?;
18    value.as_deref().map(str::parse).transpose().map_err(serde::de::Error::custom)
19}
20
21pub fn default_for_null<'de, D, T>(deserializer: D) -> Result<T, D::Error>
22where
23    D: Deserializer<'de>,
24    T: Deserialize<'de> + Default,
25{
26    Ok(Option::<T>::deserialize(deserializer)?.unwrap_or_default())
27}
28
29pub mod json_string_opt {
30    use serde::{
31        Deserialize, Deserializer, Serialize, Serializer,
32        de::{self, DeserializeOwned},
33    };
34
35    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
36    where
37        S: Serializer,
38        T: Serialize,
39    {
40        if let Some(value) = value {
41            value.serialize(serializer)
42        } else {
43            serializer.serialize_none()
44        }
45    }
46
47    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
48    where
49        D: Deserializer<'de>,
50        T: DeserializeOwned,
51    {
52        if let Some(s) = Option::<String>::deserialize(deserializer)? {
53            if s.is_empty() {
54                return Ok(None);
55            }
56            let value = serde_json::Value::String(s);
57            serde_json::from_value(value).map_err(de::Error::custom).map(Some)
58        } else {
59            Ok(None)
60        }
61    }
62}
63
64/// deserializes empty json object `{}` as `None`
65pub mod empty_json_object_opt {
66    use serde::{
67        Deserialize, Deserializer, Serialize, Serializer,
68        de::{self, DeserializeOwned},
69    };
70
71    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
72    where
73        S: Serializer,
74        T: Serialize,
75    {
76        if let Some(value) = value {
77            value.serialize(serializer)
78        } else {
79            let empty = serde_json::Value::Object(Default::default());
80            serde_json::Value::serialize(&empty, serializer)
81        }
82    }
83
84    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
85    where
86        D: Deserializer<'de>,
87        T: DeserializeOwned,
88    {
89        let json = serde_json::Value::deserialize(deserializer)?;
90        if json.is_null() {
91            return Ok(None);
92        }
93        if json.as_object().map(|obj| obj.is_empty()).unwrap_or_default() {
94            return Ok(None);
95        }
96        serde_json::from_value(json).map_err(de::Error::custom).map(Some)
97    }
98}
99
100/// serde support for string
101pub mod string_bytes {
102    use serde::{Deserialize, Deserializer, Serializer};
103
104    pub fn serialize<S>(value: &String, serializer: S) -> Result<S::Ok, S::Error>
105    where
106        S: Serializer,
107    {
108        if value.starts_with("0x") {
109            serializer.serialize_str(value.as_str())
110        } else {
111            serializer.serialize_str(&format!("0x{value}"))
112        }
113    }
114
115    pub fn deserialize<'de, D>(deserializer: D) -> Result<String, D::Error>
116    where
117        D: Deserializer<'de>,
118    {
119        let value = String::deserialize(deserializer)?;
120        if let Some(rem) = value.strip_prefix("0x") { Ok(rem.to_string()) } else { Ok(value) }
121    }
122}
123
124pub mod display_from_str_opt {
125    use serde::{Deserialize, Deserializer, Serializer, de};
126    use std::{fmt, str::FromStr};
127
128    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
129    where
130        T: fmt::Display,
131        S: Serializer,
132    {
133        if let Some(value) = value {
134            serializer.collect_str(value)
135        } else {
136            serializer.serialize_none()
137        }
138    }
139
140    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
141    where
142        D: Deserializer<'de>,
143        T: FromStr,
144        T::Err: fmt::Display,
145    {
146        if let Some(s) = Option::<String>::deserialize(deserializer)? {
147            s.parse().map_err(de::Error::custom).map(Some)
148        } else {
149            Ok(None)
150        }
151    }
152}
153
154pub mod display_from_str {
155    use serde::{Deserialize, Deserializer, Serializer, de};
156    use std::{fmt, str::FromStr};
157
158    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
159    where
160        T: fmt::Display,
161        S: Serializer,
162    {
163        serializer.collect_str(value)
164    }
165
166    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
167    where
168        D: Deserializer<'de>,
169        T: FromStr,
170        T::Err: fmt::Display,
171    {
172        String::deserialize(deserializer)?.parse().map_err(de::Error::custom)
173    }
174}
175
176/// (De)serialize vec of tuples as map
177pub mod tuple_vec_map {
178    use serde::{Deserialize, Deserializer, Serialize, Serializer, de::DeserializeOwned};
179
180    pub fn serialize<K, V, S>(data: &[(K, V)], serializer: S) -> Result<S::Ok, S::Error>
181    where
182        S: Serializer,
183        K: Serialize,
184        V: Serialize,
185    {
186        serializer.collect_map(data.iter().map(|x| (&x.0, &x.1)))
187    }
188
189    pub fn deserialize<'de, K, V, D>(deserializer: D) -> Result<Vec<(K, V)>, D::Error>
190    where
191        D: Deserializer<'de>,
192        K: DeserializeOwned,
193        V: DeserializeOwned,
194    {
195        use serde::de::{MapAccess, Visitor};
196        use std::{fmt, marker::PhantomData};
197
198        struct TupleVecMapVisitor<K, V> {
199            marker: PhantomData<Vec<(K, V)>>,
200        }
201
202        impl<K, V> TupleVecMapVisitor<K, V> {
203            pub const fn new() -> Self {
204                Self { marker: PhantomData }
205            }
206        }
207
208        impl<'de, K, V> Visitor<'de> for TupleVecMapVisitor<K, V>
209        where
210            K: Deserialize<'de>,
211            V: Deserialize<'de>,
212        {
213            type Value = Vec<(K, V)>;
214
215            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
216                formatter.write_str("a map")
217            }
218
219            #[inline]
220            fn visit_unit<E>(self) -> Result<Vec<(K, V)>, E> {
221                Ok(Vec::new())
222            }
223
224            #[inline]
225            fn visit_map<T>(self, mut access: T) -> Result<Vec<(K, V)>, T::Error>
226            where
227                T: MapAccess<'de>,
228            {
229                let mut values =
230                    Vec::with_capacity(std::cmp::min(access.size_hint().unwrap_or(0), 4096));
231
232                while let Some((key, value)) = access.next_entry()? {
233                    values.push((key, value));
234                }
235
236                Ok(values)
237            }
238        }
239
240        deserializer.deserialize_map(TupleVecMapVisitor::new())
241    }
242}
foundry_compilers_artifacts_solc/serde_helpers.rs

foundry_compilers_artifacts_solc/
serde_helpers.rs
