libddwaf/
serde.rs

1//! Implementations of [`serde::Deserialize`] for [`object::WafObject`](crate::object::WafObject) and
2//! [`object::WafMap`](crate::object::WafMap).
3
4use std::borrow::Cow;
5
6use serde::{
7    Deserializer,
8    de::Error,
9    ser::{SerializeMap, SerializeSeq},
10};
11
12use crate::object::{
13    WafArray, WafBool, WafFloat, WafMap, WafObject, WafObjectType, WafSigned, WafString,
14    WafUnsigned,
15};
16
17impl<'de> serde::Deserialize<'de> for WafObject {
18    fn deserialize<D>(deserializer: D) -> Result<WafObject, D::Error>
19    where
20        D: Deserializer<'de>,
21    {
22        deserializer.deserialize_any(Visitor)
23    }
24}
25
26impl<'de> serde::Deserialize<'de> for WafMap {
27    fn deserialize<D>(deserializer: D) -> Result<WafMap, D::Error>
28    where
29        D: Deserializer<'de>,
30    {
31        let dobj = deserializer.deserialize_any(Visitor)?;
32        dobj.try_into()
33            .map_err(|_| serde::de::Error::custom("invalid type: not a map"))
34    }
35}
36
37struct Visitor;
38
39impl<'de> serde::de::Visitor<'de> for Visitor {
40    type Value = WafObject;
41
42    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
43        formatter.write_str(
44            "a valid WafObject (unsigned, signed, string, array, map, bool, float, or null)",
45        )
46    }
47
48    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
49    where
50        E: Error,
51    {
52        Ok(WafObject::from(v))
53    }
54
55    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
56    where
57        E: Error,
58    {
59        Ok(WafObject::from(v))
60    }
61
62    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
63    where
64        E: Error,
65    {
66        Ok(WafObject::from(v))
67    }
68
69    fn visit_unit<E>(self) -> Result<Self::Value, E>
70    where
71        E: Error,
72    {
73        Ok(WafObject::from(()))
74    }
75
76    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
77    where
78        E: Error,
79    {
80        Ok(WafObject::from(v))
81    }
82
83    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
84    where
85        E: Error,
86    {
87        Ok(WafObject::from(WafString::new(v)))
88    }
89
90    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
91    where
92        A: serde::de::SeqAccess<'de>,
93    {
94        let mut vec = seq.size_hint().map(Vec::with_capacity).unwrap_or_default();
95        while let Some(value) = seq.next_element()? {
96            vec.push(value);
97        }
98        let mut res = WafArray::new(vec.len().try_into().unwrap());
99        for (i, v) in vec.into_iter().enumerate() {
100            res[i] = v;
101        }
102        Ok(res.into())
103    }
104
105    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
106    where
107        A: serde::de::MapAccess<'de>,
108    {
109        let mut vec: Vec<(Cow<'de, str>, WafObject)> =
110            map.size_hint().map(Vec::with_capacity).unwrap_or_default();
111        while let Some((key, value)) = map.next_entry::<Cow<'de, str>, WafObject>()? {
112            vec.push((key, value));
113        }
114        let mut res = WafMap::new(vec.len().try_into().unwrap());
115        for (i, (k, v)) in vec.into_iter().enumerate() {
116            let key_str: &str = &k;
117            res[i] = (key_str, v).into();
118        }
119        Ok(res.into())
120    }
121}
122
123impl serde::Serialize for WafObject {
124    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
125    where
126        S: serde::Serializer,
127    {
128        match self.get_type() {
129            WafObjectType::Unsigned => {
130                unsafe { self.as_type_unchecked::<WafUnsigned>() }.serialize(serializer)
131            }
132            WafObjectType::Signed => {
133                unsafe { self.as_type_unchecked::<WafSigned>() }.serialize(serializer)
134            }
135            WafObjectType::Bool => {
136                unsafe { self.as_type_unchecked::<WafBool>() }.serialize(serializer)
137            }
138            WafObjectType::Float => {
139                unsafe { self.as_type_unchecked::<WafFloat>() }.serialize(serializer)
140            }
141            WafObjectType::String => {
142                unsafe { self.as_type_unchecked::<WafString>() }.serialize(serializer)
143            }
144            WafObjectType::Array => {
145                unsafe { self.as_type_unchecked::<WafArray>() }.serialize(serializer)
146            }
147            WafObjectType::Map => {
148                unsafe { self.as_type_unchecked::<WafMap>() }.serialize(serializer)
149            }
150            WafObjectType::Null | WafObjectType::Invalid => serializer.serialize_unit(),
151        }
152    }
153}
154
155impl serde::Serialize for WafUnsigned {
156    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
157    where
158        S: serde::Serializer,
159    {
160        serializer.serialize_u64(self.value())
161    }
162}
163
164impl serde::Serialize for WafSigned {
165    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
166    where
167        S: serde::Serializer,
168    {
169        serializer.serialize_i64(self.value())
170    }
171}
172
173impl serde::Serialize for WafBool {
174    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
175    where
176        S: serde::Serializer,
177    {
178        serializer.serialize_bool(self.value())
179    }
180}
181
182impl serde::Serialize for WafFloat {
183    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
184    where
185        S: serde::Serializer,
186    {
187        serializer.serialize_f64(self.value())
188    }
189}
190
191impl serde::Serialize for WafString {
192    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
193    where
194        S: serde::Serializer,
195    {
196        serializer.serialize_str(&String::from_utf8_lossy(self.bytes()))
197    }
198}
199
200impl serde::Serialize for WafArray {
201    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
202    where
203        S: serde::Serializer,
204    {
205        let mut seq_serializer = serializer.serialize_seq(Some(self.len()))?;
206        for value in self.iter() {
207            seq_serializer.serialize_element(value)?;
208        }
209        seq_serializer.end()
210    }
211}
212
213impl serde::Serialize for WafMap {
214    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
215    where
216        S: serde::Serializer,
217    {
218        let mut map_serializer = serializer.serialize_map(Some(self.len()))?;
219        for keyed_val in self.iter() {
220            map_serializer
221                .serialize_entry(&String::from_utf8_lossy(keyed_val.key()), keyed_val.inner())?;
222        }
223        map_serializer.end()
224    }
225}
libddwaf/serde.rs

libddwaf/
serde.rs
